omf_common 6.0.0.pre.6 → 6.0.0.pre.7

data/lib/omf_common.rb

@@ -5,8 +5,12 @@ require "omf_common/version"
 require "omf_common/message"
 require "omf_common/comm"
 require "omf_common/command"
+require "omf_common/topic"
+require "omf_common/topic_message"
 require "omf_common/core_ext/string"
+require "omf_common/core_ext/object"
 
+# Use global default logger from logging gem
 include Logging.globally
 
 Logging.appenders.stdout('stdout',

data/lib/omf_common/core_ext/object.rb

@@ -0,0 +1,21 @@
+class Object
+  def stub name, val_or_callable, &block
+    new_name = "__minitest_stub__#{name}"
+    metaclass = class << self; self; end
+    metaclass.send :alias_method, new_name, name
+    metaclass.send :define_method, name do |*args, &stub_block|
+      if val_or_callable.respond_to? :call then
+        val_or_callable.call(*args, &stub_block)
+      else
+        val_or_callable
+      end
+    end
+    yield self
+  ensure
+    metaclass.send :undef_method, name
+    metaclass.send :alias_method, name, new_name
+    metaclass.send :undef_method, new_name
+  end
+end
+
+

data/lib/omf_common/dsl/xmpp.rb

@@ -33,55 +33,105 @@ module OmfCommon
       # Create a new pubsub topic with additional configuration
       #
       # @param [String] topic Pubsub topic name
-      # @param [String] host Pubsub host address
-      def create_topic(topic, host, &block)
-        pubsub.create(topic, prefix_host(host), PUBSUB_CONFIGURE, &callback_logging(__method__, topic, &block))
+      def create_topic(topic, &block)
+        pubsub.create(topic, default_host, PUBSUB_CONFIGURE, &callback_logging(__method__, topic, &block))
       end
 
       # Delete a pubsub topic
       #
       # @param [String] topic Pubsub topic name
-      # @param [String] host Pubsub host address
-      def delete_topic(topic, host, &block)
-        pubsub.delete(topic, prefix_host(host), &callback_logging(__method__, topic, &block))
+      def delete_topic(topic, &block)
+        pubsub.delete(topic, default_host, &callback_logging(__method__, topic, &block))
       end
 
       # Subscribe to a pubsub topic
       #
       # @param [String] topic Pubsub topic name
-      # @param [String] host Pubsub host address
-      def subscribe(topic, host, &block)
-        pubsub.subscribe(topic, nil, prefix_host(host), &callback_logging(__method__, topic, &block))
+      def subscribe(topic, &block)
+        pubsub.subscribe(topic, nil, default_host, &callback_logging(__method__, topic, &block))
       end
 
       # Un-subscribe all existing subscriptions from all pubsub topics.
-      #
-      # @param [String] host Pubsub host address
-      def unsubscribe(host)
-        pubsub.subscriptions(prefix_host(host)) do |m|
+      def unsubscribe
+        pubsub.subscriptions(default_host) do |m|
           m[:subscribed] && m[:subscribed].each do |s|
-            pubsub.unsubscribe(s[:node], nil, s[:subid], prefix_host(host), &callback_logging(__method__, s[:node], s[:subid]))
+            pubsub.unsubscribe(s[:node], nil, s[:subid], default_host, &callback_logging(__method__, s[:node], s[:subid]))
           end
         end
       end
 
-      def affiliations(host, &block)
-        pubsub.affiliations(prefix_host(host), &callback_logging(__method__, &block))
+      def affiliations(&block)
+        pubsub.affiliations(default_host, &callback_logging(__method__, &block))
       end
 
       # Publish to a pubsub topic
       #
       # @param [String] topic Pubsub topic name
       # @param [String] message Any XML fragment to be sent as payload
-      # @param [String] host Pubsub host address
-      def publish(topic, message, host, &block)
-        pubsub.publish(topic, message, prefix_host(host), &callback_logging(__method__, topic, message.operation, &block))
+      def publish(topic, message, &block)
+        raise StandardError, "Invalid message" unless message.valid?
+        pubsub.publish(topic, message, default_host, &callback_logging(__method__, topic, message.operation, &block))
+      end
+
+      # Generate OMF related message
+      %w(create configure request inform release).each do |m_name|
+        define_method("#{m_name}_message") do |*args, &block|
+          message =
+            if block
+              Message.send(m_name, *args, &block)
+            elsif args[0].kind_of? Array
+              Message.send(m_name) do |v|
+                args[0].each do |opt|
+                  if opt.kind_of? Hash
+                    opt.each_pair do |key, value|
+                      v.property(key, value)
+                    end
+                  else
+                    v.property(opt)
+                  end
+                end
+              end
+            end
+
+          OmfCommon::TopicMessage.new(message, self)
+        end
+      end
+
+      # Event machine related method delegation
+      %w(add_timer add_periodic_timer).each do |m_name|
+        define_method(m_name) do |*args, &block|
+          EM.send(m_name, *args, &block)
+        end
+      end
+
+      %w(created status released failed).each do |inform_type|
+        define_method("on_#{inform_type}_message") do |*args, &message_block|
+          context_id = args[0].context_id if args[0]
+          event_block = proc do |event|
+            message_block.call(Message.parse(event.items.first.payload))
+          end
+          guard_block = proc do |event|
+            (event.items?) && (!event.delayed?) &&
+              event.items.first.payload &&
+              (omf_message = Message.parse(event.items.first.payload)) &&
+              omf_message.operation == :inform &&
+              omf_message.read_content(:inform_type) == inform_type.upcase &&
+              (context_id ? (omf_message.context_id == context_id) : true)
+          end
+          pubsub_event(guard_block, &callback_logging(__method__, &event_block))
+        end
       end
 
       # Event callback for pubsub topic event(item published)
       #
       def topic_event(*args, &block)
-        pubsub_event(:items?, *args, &callback_logging(__method__, &block))
+        pubsub_event(*args, &callback_logging(__method__, &block))
+      end
+
+      # Return a topic object represents pubsub topic
+      #
+      def get_topic(topic_id)
+        OmfCommon::Topic.new(topic_id, self)
       end
 
       private
@@ -96,8 +146,8 @@ module OmfCommon
         end
       end
 
-      def prefix_host(host)
-        "#{HOST_PREFIX}.#{host}"
+      def default_host
+        "#{HOST_PREFIX}.#{client.jid.domain}"
       end
     end
   end

data/lib/omf_common/exec_app.rb

@@ -0,0 +1,163 @@
+#
+# Copyright (c) 2006-2012 National ICT Australia (NICTA), Australia
+#
+# Copyright (c) 2004-2009 WINLAB, Rutgers University, USA
+#
+# 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.
+#
+#
+# Library of client side helpers
+#
+require 'fcntl'
+
+#
+# Run an application on the client.
+#
+# Borrows from Open3
+#
+class ExecApp
+
+  # Holds the pids for all active apps
+  @@all_apps = Hash.new
+
+  # True if this active app is being killed by a proper
+  # call to ExecApp.signal_all() or signal()
+  # (i.e. when the caller of ExecApp decided to stop the application,
+  # as far as we are concerned, this is a 'clean' exit)
+  @clean_exit = false
+
+  # Return an application instance based on its ID
+  #
+  # @param [String] id of the application to return
+  def ExecApp.[](id)
+    app = @@all_apps[id]
+    logger.info "Unknown application '#{id}/#{id.class}'" if app.nil?
+    return app
+  end
+
+  def ExecApp.signal_all(signal = 'KILL')
+    @@all_apps.each_value { |app| app.signal(signal) }
+  end
+
+  def stdin(line)
+    logger.debug "Writing '#{line}' to app '#{@id}'"
+    @stdin.write("#{line}\n")
+    @stdin.flush
+  end
+
+  def signal(signal = 'KILL')
+    @clean_exit = true
+    Process.kill(signal, @pid)
+  end
+
+  #
+  # Run an application 'cmd' in a separate thread and monitor
+  # its stdout. Also send status reports to the 'observer' by
+  # calling its "on_app_event(eventType, appId, message")"
+  #
+  # @param id ID of application (used for reporting)
+  # @param observer Observer of application's progress
+  # @param cmd Command path and args
+  # @param map_std_err_to_out If true report stderr as stdin [false]
+  #
+  def initialize(id, observer, cmd, map_std_err_to_out = false)
+
+    @id = id
+    @observer = observer
+    @@all_apps[id] = self
+
+    pw = IO::pipe   # pipe[0] for read, pipe[1] for write
+    pr = IO::pipe
+    pe = IO::pipe
+
+    logger.debug "Starting application '#{id}' - cmd: '#{cmd}'"
+    @observer.on_app_event(:STARTED, id, cmd)
+    @pid = fork {
+      # child will remap pipes to std and exec cmd
+      pw[1].close
+      STDIN.reopen(pw[0])
+      pw[0].close
+
+      pr[0].close
+      STDOUT.reopen(pr[1])
+      pr[1].close
+
+      pe[0].close
+      STDERR.reopen(pe[1])
+      pe[1].close
+
+      begin
+        exec(cmd)
+      rescue => ex
+        cmd = cmd.join(' ') if cmd.kind_of?(Array)
+        STDERR.puts "exec failed for '#{cmd}' (#{$!}): #{ex}"
+      end
+      # Should never get here
+      exit!
+    }
+
+    pw[0].close
+    pr[1].close
+    pe[1].close
+    monitor_pipe(:stdout, pr[0])
+    monitor_pipe(map_std_err_to_out ? :stdout : :stderr, pe[0])
+    # Create thread which waits for application to exit
+    Thread.new(id, @pid) do |id, pid|
+      ret = Process.waitpid(pid)
+      status = $?
+      @@all_apps.delete(@id)
+      # app finished
+      if (status == 0) || @clean_exit
+        s = "OK"
+        logger.debug "Application '#{id}' finished"
+      else
+        s = "ERROR"
+        logger.debug "Application '#{id}' failed (code=#{status})"
+      end
+      @observer.on_app_event("DONE.#{s}", @id, "status: #{status}")
+    end
+    @stdin = pw[1]
+  end
+
+  private
+
+  #
+  # Create a thread to monitor the process and its output
+  # and report that back to the server
+  #
+  # @param name Name of app stream to monitor (should be :stdout, :stderr)
+  # @param pipe Pipe to read from
+  #
+  def monitor_pipe(name, pipe)
+    Thread.new() do
+      begin
+        while true do
+          s = pipe.readline.chomp
+          @observer.on_app_event(name.to_s.upcase, @id, s)
+        end
+      rescue EOFError
+        # do nothing
+      rescue Exception => err
+        logger.error "monitorApp(#{@id}): #{err}"
+      ensure
+        pipe.close
+      end
+    end
+  end
+end

data/lib/omf_common/message.rb

@@ -10,23 +10,25 @@ module OmfCommon
   #
   #   Message.request do |message|
   #     message.property('os', 'debian')
-  #     message.property('memory', 2) do |p|
-  #       p.element('unit', 'gb')
-  #     end
+  #     message.property('memory', { value: 2, unit: 'gb' })
   #   end
   #
   class Message < Niceogiri::XML::Node
     OMF_NAMESPACE = "http://schema.mytestbed.net/#{OmfCommon::PROTOCOL_VERSION}/protocol"
-    SCHEMA_FILE = "#{File.dirname(__FILE__)}/protocol.rng"
+    SCHEMA_FILE = "#{File.dirname(__FILE__)}/protocol/#{OmfCommon::PROTOCOL_VERSION}.rng"
     OPERATION = %w(create configure request release inform)
 
     class << self
       OPERATION.each do |operation|
         define_method(operation) do |*args, &block|
           xml = new(operation, nil, OMF_NAMESPACE)
-          xml.element('context_id', operation == 'inform' ? args[0] : SecureRandom.uuid)
+          if operation == 'inform'
+            xml.element('context_id', args[1] || SecureRandom.uuid)
+            xml.element('inform_type', args[0])
+          else
+            xml.element('context_id', SecureRandom.uuid)
+          end
           xml.element('publish_to', args[0]) if operation == 'request'
-          xml.element('inform_type', args[1]) if operation == 'inform'
           block.call(xml) if block
           xml.sign
         end
@@ -40,17 +42,62 @@ module OmfCommon
 
     # Construct a property xml node
     #
-    def property(key, value = nil, &block)
+    def property(key, value = nil)
       key_node = Message.new('property')
       key_node.write_attr('key', key)
+
+      unless value.nil?
+        key_node.write_attr('type', value.class.to_s.downcase)
+        c_node = value_node_set(value)
+
+        if c_node.class == Array
+          c_node.each { |c_n| key_node.add_child(c_n) }
+        else
+          key_node.add_child(c_node)
+        end
+      end
       add_child(key_node)
-      if block
-        key_node.element('value', value) if value
-        block.call(key_node)
+      key_node
+    end
+
+    def value_node_set(value, key = nil)
+      case value
+      when Hash
+        [].tap do |array|
+          value.each_pair do |k, v|
+            n = Message.new(k)
+            n.write_attr('type', v.class.to_s.downcase)
+
+            c_node = value_node_set(v, k)
+            if c_node.class == Array
+              c_node.each { |c_n| n.add_child(c_n) }
+            else
+              n.add_child(c_node)
+            end
+            array << n
+          end
+        end
+      when Array
+        value.map do |v|
+          n = Message.new('item')
+          n.write_attr('type', v.class.to_s.downcase)
+
+          c_node = value_node_set(v, 'item')
+          if c_node.class == Array
+            c_node.each { |c_n| n.add_child(c_n) }
+          else
+            n.add_child(c_node)
+          end
+          n
+        end
       else
-        key_node.content = value if value
+        if key.nil?
+          value.to_s
+        else
+          n = Message.new(key)
+          n.add_child(value.to_s)
+        end
       end
-      key_node
     end
 
     # Generate SHA1 of canonicalised xml and write into the ID attribute of the message
@@ -63,21 +110,26 @@ module OmfCommon
     # Validate against relaxng schema
     #
     def valid?
-      validation = Nokogiri::XML::RelaxNG(File.open(SCHEMA_FILE)).validate(document)
+      validation = Nokogiri::XML::RelaxNG(File.open(SCHEMA_FILE)).validate(self.document)
       if validation.empty?
         true
       else
         logger.error validation.map(&:message).join("\n")
+        logger.debug self.to_s
         false
       end
     end
 
     # Short cut for adding xml node
     #
-    def element(key, value)
-      key_node = Niceogiri::XML::Node.new(key)
-      key_node.content = value
+    def element(key, value = nil, &block)
+      key_node = Message.new(key)
       add_child(key_node)
+      if block
+        block.call(key_node)
+      else
+        key_node.content = value if value
+      end
     end
 
     # The root element_name represents operation
@@ -98,7 +150,18 @@ module OmfCommon
     # We just want to know the content of an non-repeatable element
     #
     def read_content(element_name)
-      read_element("//#{element_name}").first.content rescue nil
+      element_content = read_element("//#{element_name}").first.content rescue nil
+      element_content.empty? ? nil : element_content
+    end
+
+    # Context ID will be requested quite often
+    def context_id
+      read_property(:context_id) || read_content(:context_id)
+    end
+
+    # Resource ID is another frequent requested property
+    def resource_id
+      read_property(:resource_id) || read_content(:resource_id)
     end
 
     # Get a property by key
@@ -109,17 +172,38 @@ module OmfCommon
     def read_property(key)
       key = key.to_s
       e = read_element("//property[@key='#{key}']").first
-      if e
-        if e.children.size == 1
-          e.content.ducktype
-        else
-          Hashie::Mash.new.tap do |mash|
-            e.element_children.each do |child|
-              mash[child.element_name] ||= child.content.ducktype
-            end
-          end
+      reconstruct_data(e) if e
+    end
+
+    def reconstruct_data(node)
+      case node.attr('type')
+      when 'array'
+        mash ||= Hashie::Mash.new
+        mash[:items] = node.element_children.map do |child|
+          reconstruct_data(child)
         end
+        mash
+      when /hash/
+        mash ||= Hashie::Mash.new
+        node.element_children.each do |child|
+          mash[child.attr('key') || child.element_name] ||= reconstruct_data(child)
+        end
+        mash
+      else
+        node.content.empty? ? nil : node.content.ducktype
       end
     end
+
+    # Iterate each property element
+    #
+    def each_property(&block)
+      read_element("//property").each { |v| block.call(v) }
+    end
+
+    # Pretty print for application event message
+    #
+    def print_app_event
+      "APP_EVENT (#{read_property(:app)}, ##{read_property(:seq)}, #{read_property(:event)}): #{read_property(:msg)}"
+    end
   end
 end