omf_common 6.0.0.pre.10 → 6.0.0.pre.11

data/lib/omf_common/{dsl → comm/xmpp}/xmpp_mp.rb

@@ -1,3 +1,5 @@
+require 'oml4r'
+
 module OmfCommon
   module DSL
     module Xmpp

data/lib/omf_common/eventloop.rb

@@ -0,0 +1,94 @@
+module OmfCommon
+  # Providing event loop support.
+  class Eventloop
+    
+    @@providers = {
+      em: {
+        require: 'omf_common/eventloop/em',
+        constructor: 'OmfCommon::Eventloop::EventMachine'
+      },
+      local: {
+        require: 'omf_common/eventloop/local_evl',
+        constructor: 'OmfCommon::Eventloop::Local'
+      }
+    }
+    @@instance = nil
+    
+    #
+    # opts:
+    #   :type - eventloop provider
+    #   :provider - custom provider (opts)
+    #     :require - gem to load first (opts)
+    #     :constructor - Class implementing provider
+    #
+    def self.init(opts, &block)
+      if @@instance
+        raise "Eventloop provider already iniitalised"
+      end
+      unless provider = opts[:provider]
+        provider = @@providers[opts[:type].to_sym]
+      end
+      unless provider
+        raise "Missing Eventloop provider declaration. Either define 'type' or 'provider'"
+      end
+
+      require provider[:require] if provider[:require]
+
+      if class_name = provider[:constructor]
+        provider_class = class_name.split('::').inject(Object) {|c,n| c.const_get(n) }
+        inst = provider_class.new(opts, &block)
+      else
+        raise "Missing provider creation info - :constructor"
+      end
+      @@instance = inst
+      inst
+    end
+    
+    def self.instance
+      @@instance
+    end
+    
+    # Execute block after some time
+    #
+    # @param [float] delay in sec
+    # @param [block] block to execute
+    #
+    def after(delay_sec, &block)
+      raise "Missing implementation 'after'"
+    end
+    
+    # Periodically call block every interval_sec
+    #
+    # @param [float] interval in sec
+    # @param [block] block to execute
+    #
+    def every(interval_sec, &block)
+      raise "Missing implementation 'every'"
+    end
+    
+    # Block calling thread until eventloop exits
+    def join()
+      raise "Missing implementation 'join'"
+    end
+    
+    def run()
+      raise "Missing implementation 'run'"      
+    end
+    
+    def stop()
+      raise "Missing implementation 'stop'"      
+    end      
+    
+    # Calling 'block' before stopping eventloop
+    #
+    def on_stop(&block)
+      warn "Missing implementation 'on_stop'" 
+    end
+
+    private
+    def initialize(opts = {}, &block)
+      #run(&block) if block
+    end
+    
+  end
+end

data/lib/omf_common/eventloop/em.rb

@@ -0,0 +1,57 @@
+require 'eventmachine'
+
+module OmfCommon
+  class Eventloop
+    # Implements a simple eventloop which only deals with timer events
+    #
+    class EventMachine < Eventloop
+
+      def initialize(opts = {}, &block)
+        super
+        @deferred =  []
+        @deferred << block if block
+      end
+
+      # Execute block after some time
+      #
+      # @param [Float] delay in sec
+      def after(delay_sec, &block)
+        if EM.reactor_running?
+          EM.add_timer(delay_sec, &block)
+        else
+          @deferred << lambda do
+            EM.add_timer(delay_sec, &block)
+          end
+        end
+      end
+
+      # Periodically call block every interval_sec
+      #
+      # @param [Float] interval in sec
+      def every(interval_sec, &block)
+        if EM.reactor_running?
+          EM.add_periodic_timer(interval_sec, &block)
+        else
+          @deferred << lambda do
+            EM.add_periodic_timer(interval_sec, &block)
+          end
+        end
+      end
+
+      def run(&block)
+        EM.run do
+          @deferred.each { |proc| proc.call }
+          @deferred = nil
+          if block
+            block.arity == 0 ? block.call : block.call(self)
+          end
+        end
+      end
+
+      def stop()
+        EM.stop
+      end
+    end # class
+  end
+end
+

data/lib/omf_common/eventloop/local_evl.rb

@@ -0,0 +1,78 @@
+
+
+module OmfCommon
+  class Eventloop
+    # Implements a simple eventloop which only deals with timer events
+    #
+    class Local < Eventloop
+      
+      def initialize(opts = {}, &block)
+        super
+        @tasks =  []
+        @running = false
+        after(0, &block) if block
+      end
+      
+      # Execute block after some time
+      #
+      # @param [float] delay in sec
+      # @param [block] block to execute
+      #
+      def after(delay_sec, &block)
+        @tasks << [Time.now + delay_sec, block]
+      end
+      
+      # Periodically call block every interval_sec
+      #
+      # @param [float] interval in sec
+      # @param [block] block to execute
+      #
+      def every(interval_sec, &block)
+        @tasks << [Time.now + interval_sec, block, :periodic => interval_sec]
+      end
+      
+      def stop 
+        @running = false
+      end
+      
+      def run(&block)
+        after(0, &block) if block
+        return if @running
+        @running = true
+              
+        while @running do
+          now = Time.now
+          @tasks = @tasks.sort
+          while @tasks[0] && @tasks[0][0] <= now
+            # execute
+            t = @tasks.shift
+            debug "Executing Task #{t}"
+            block = t[1]
+            block.arity == 0 ? block.call : block.call(self)
+            now = Time.now
+            # Check if periodic
+            if interval = ((t[2] || {})[:periodic])
+              if (next_time = t[0] + interval) < now
+                warn "Falling behind with periodic task #{t[1]}"
+                next_time = now + interval
+              end
+              @tasks << [next_time, t[1], :periodic => interval]
+            end
+          end
+          # by now, there could have been a few more tasks added, so let's sort again
+          @tasks = @tasks.sort
+          if @tasks.empty?
+            # done
+            @running = false
+          else
+            if (delay = @tasks[0][0] - Time.now) > 0
+              debug "Sleeping #{delay}"
+              sleep delay
+            end
+          end
+        end
+      end      
+    end # class
+  end
+end
+      

data/lib/omf_common/message.rb

@@ -1,293 +1,176 @@
-require 'niceogiri'
-require 'hashie'
-require 'securerandom'
-require 'openssl'
-require 'cgi'
-require 'omf_common/relaxng_schema'
-
 module OmfCommon
 
   class MPMessage < OML4R::MPBase
     name :message
     param :time, :type => :double
     param :operation, :type => :string
-    param :msg_id, :type => :string
-    param :context_id, :type => :string
+    param :mid, :type => :string
+    param :cid, :type => :string
     param :content, :type => :string
   end
 
-  # Refer to resource life cycle, instance methods are basically construct & parse XML fragment
-  #
-  # @example To create a valid omf message, e.g. a 'configure' message:
-  #
-  #   Message.request do |message|
-  #     message.property('os', 'debian')
-  #     message.property('memory', { value: 2, unit: 'gb' })
-  #   end
-  #
-  class Message < Niceogiri::XML::Node
+  class Message
+
     OMF_NAMESPACE = "http://schema.mytestbed.net/omf/#{OmfCommon::PROTOCOL_VERSION}/protocol"
-    OPERATION = %w(create configure request release inform)
-    # When OML instrumentation is enabled, we do not want to send a the same
-    # measurement twice, once when a message is created for publishing to T,
-    # and once when this message comes back (as we are also a subscriber of T)
-    # Thus we keep track of message IDs here (again only when OML is enabled)
-    @@msg_id_list = []
-
-    class << self
-      OPERATION.each do |operation|
-        define_method(operation) do |*args, &block|
-          xml = new(operation, nil, OMF_NAMESPACE)
-          if operation == 'inform'
-            xml.element('context_id', args[1]) if args[1]
-            xml.element('inform_type', args[0])
-          else
-            xml.element('publish_to', args[0]) if args[0]
-          end
-          block.call(xml) if block
-          xml.sign
-        end
-      end
+    OMF_CORE_READ = [:operation, :ts, :src, :mid, :replyto, :cid, :itype, :rtype, :guard, :res_id]
+    OMF_CORE_WRITE = [:replyto, :itype, :guard]
 
-      def parse(xml)
-        raise ArgumentError, 'Can not parse an empty XML into OMF message' if xml.nil? || xml.empty?
-        xml_root = Nokogiri::XML(xml).root
-        result = new(xml_root.element_name, nil, xml_root.namespace.href).inherit(xml_root)
-        if OmfCommon::Measure.enabled? && !@@msg_id_list.include?(result.msg_id)
-          MPMessage.inject(Time.now.to_f, result.operation.to_s, result.msg_id, result.context_id, result.to_s.gsub("\n",''))
-        end
-        result
-      end
-    end
+    @@providers = {
+      xml: {
+        require: 'omf_common/message/xml/message',
+        constructor: 'OmfCommon::Message::XML::Message'
+      },
+      json: {
+        require: 'omf_common/message/json/json_message',
+        constructor: 'OmfCommon::Message::Json::Message'
+      }
+    }
+    @@message_class = nil
 
-    # Construct a property xml node
-    #
-    def property(key, value = nil)
-      key_node = Message.new('property')
-      key_node.write_attr('key', key)
-
-      unless value.nil?
-        key_node.write_attr('type', ruby_type_2_prop_type(value.class))
-        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)
-      key_node
+    def self.create(type, properties, body = {})
+      @@message_class.create(type, properties, body)
     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', ruby_type_2_prop_type(v.class))
-
-            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', ruby_type_2_prop_type(v.class))
-
-          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
-        if key.nil?
-          string_value(value)
-        else
-          n = Message.new(key)
-          n.add_child(string_value(value))
-        end
-      end
+    def self.create_inform_message(itype = nil, properties = {}, body = {})
+      body[:itype] = itype if itype
+      create(:inform, properties, body)
     end
 
-    # Generate SHA1 of canonicalised xml and write into the ID attribute of the message
+    # Create and return a message by parsing 'str'
     #
-    def sign
-      write_attr('msg_id', SecureRandom.uuid)
-      write_attr('timestamp', Time.now.utc.iso8601)
-      canonical_msg = self.canonicalize
+    def self.parse(str)
+      @@message_class.parse(str)
+    end
 
-      priv_key =  OmfCommon::Key.instance.private_key
-      digest = OpenSSL::Digest::SHA512.new(canonical_msg)
+    def self.init(opts = {})
+      if @@message_class
+        raise "Message provider already iniitalised"
+      end
+      unless provider = opts[:provider]
+        provider = @@providers[opts[:type]]
+      end
+      unless provider
+        raise "Missing Message provider declaration. Either define 'type' or 'provider'"
+      end
 
-      signature = Base64.encode64(priv_key.sign(digest, canonical_msg)).encode('utf-8') if priv_key
-      write_attr('digest', digest)
-      write_attr('signature', signature) if signature
+      require provider[:require] if provider[:require]
 
-      if OmfCommon::Measure.enabled?
-        MPMessage.inject(Time.now.to_f, operation.to_s, msg_id, context_id, self.to_s.gsub("\n",''))
-        @@msg_id_list << msg_id
+      if class_name = provider[:constructor]
+        @@message_class = class_name.split('::').inject(Object) {|c,n| c.const_get(n) }
+      else
+        raise "Missing provider class info - :constructor"
       end
-      self
     end
 
-    # param :time, :type => :int32
-    # param :operation, :type => :string
-    # param :msg_id, :type => :string
-    # param :context_id, :type => :string
-    # param :content, :type => :string
+    OMF_CORE_READ.each do |pname|
+      define_method(pname.to_s) do |*args|
+        _get_core(pname)
+      end
+    end
 
+    alias_method :type, :operation
 
-    # Validate against relaxng schema
-    #
-    def valid?
-      validation = RelaxNGSchema.instance.schema.validate(self.document)
-      if validation.empty?
-        true
-      else
-        logger.error validation.map(&:message).join("\n")
-        logger.debug self.to_s
-        false
+    OMF_CORE_WRITE.each do |pname|
+      define_method("#{pname}=") do |val|
+        _set_core(pname.to_sym, val)
       end
     end
 
-    # Short cut for adding xml node
+    # To access properties
     #
-    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
+    # @param [String] name of the property
+    # @param [Hash] ns namespace of property
+    def [](name, ns = nil)
+      _get_property(name.to_sym, ns)
     end
 
-    # The root element_name represents operation
+    # To set properties
     #
-    def operation
-      element_name.to_sym
+    # @param [String] name of the property
+    # @param [Hash] ns namespace of property
+    def []=(name, ns = nil, value)
+      # TODO why itype cannot be set?
+      #raise if name.to_sym == :itype
+      if ns
+        @props_ns ||= {}
+        @props_ns.merge(ns)
+      end
+      _set_property(name.to_sym, value, ns)
     end
 
-    # Short cut for grabbing a group of nodes using xpath, but with default namespace
-    def element_by_xpath_with_default_namespace(xpath_without_ns)
-      xpath(xpath_without_ns.gsub(/(^|\/{1,2})(\w+)/, '\1xmlns:\2'), :xmlns => OMF_NAMESPACE)
+    def each_property(&block)
+      raise NotImplementedError
     end
 
-    # In case you think method :element_by_xpath_with_default_namespace is too long
+    # Loop over all the unbound (sent without a value) properties
+    # of a request message.
     #
-    alias_method :read_element, :element_by_xpath_with_default_namespace
+    def each_unbound_request_property(&block)
+      raise NotImplementedError
+    end
 
-    # We just want to know the content of an non-repeatable element
+    # Loop over all the bound (sent with a value) properties
+    # of a request message.
     #
-    def read_content(element_name)
-      element_content = read_element("#{element_name}").first.content rescue nil
-      unless element_content.nil?
-        element_content.empty? ? nil : element_content
-      else
-        nil
-      end
+    def each_bound_request_property(&block)
+      raise NotImplementedError
     end
 
-    # Context ID will be requested quite often
-    def context_id
-      read_property(:context_id) || read_content(:context_id)
+    def has_properties?
+      raise NotImplementedError
     end
 
-    # Resource ID is another frequent requested property
-    def resource_id
-      read_property(:resource_id) || read_content(:resource_id)
+    def resource
+      name = _get_property(:res_id)
+      OmfCommon.comm.create_topic(name)
     end
 
-    def publish_to
-      read_property(:publish_to) || read_content(:publish_to)
+    def success?
+      ! error?
     end
 
-    def msg_id
-      read_attr('msg_id')
+    def error?
+      (itype || '') =~ /(error|ERROR|FAILED)/
     end
 
-    # Get a property by key
-    #
-    # @param [String] key name of the property element
-    # @return [Object] the content of the property, as string, integer, float, or mash(hash with indifferent access)
-    #
-    def read_property(key, data_binding = nil)
-      key = key.to_s
-      e = read_element("property[@key='#{key}']").first
-      reconstruct_data(e, data_binding) if e
+    def create_inform_reply_message(itype = nil, properties = {}, body = {})
+      body[:cid] = self.mid
+      self.class.create_inform_message(itype, properties, body)
     end
 
-    def reconstruct_data(node, data_binding = nil)
-      node_type =  node.attr('type')
-      case node_type
-      when 'array'
-        node.element_children.map do |child|
-          reconstruct_data(child, data_binding)
-        end
-      when /hash/
-        mash ||= Hashie::Mash.new
-        node.element_children.each do |child|
-          mash[child.attr('key') || child.element_name] ||= reconstruct_data(child, data_binding)
-        end
-        mash
-      when /boolean/
-        node.content == "true"
-      else
-        if node.content.empty?
-          nil
-        elsif data_binding && node_type == 'string'
-          ERB.new(node.content).result(data_binding)
-        else
-          node.content.ducktype
-        end
-      end
+    def to_s
+      raise NotImplementedError
     end
 
-    # Iterate each property element
-    #
-    def each_property(&block)
-      read_element("property").each { |v| block.call(v) }
+    def marshall
+      raise NotImplementedError
     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)}"
+    def valid?
+      raise NotImplementedError
+    end
+
+    # Construct default namespace of the props from resource type
+    def default_props_ns
+      resource_type = _get_core(:rtype)
+      resource_type ? { resource_type.to_s => "#{OMF_NAMESPACE}/#{resource_type}" } : {}
+    end
+
+    # Get all property namespace defs
+    def props_ns
+      @props_ns ||= {}
+      default_props_ns.merge(@props_ns)
     end
 
     private
 
-    def ruby_type_2_prop_type(ruby_class_type)
-      v_type = ruby_class_type.to_s.downcase
-      case v_type
-      when *%w(trueclass falseclass)
-        'boolean'
-      when *%w(fixnum bignum)
-        'integer'
-      else
-        v_type
-      end
+    def  _get_property(name, ns = nil)
+      raise NotImplementedError
     end
 
-    # Get string of a value object, escape if object is string
-    def string_value(value)
-      if value.kind_of? String
-        value = CGI::escape_html(value)
-      else
-        value = value.to_s
-      end
-      value
+    def  _set_property(name, value, ns = nil)
+      raise NotImplementedError
     end
   end
+
 end