omf_rc 6.0.0.pre.8 → 6.0.0.pre.9

data/lib/omf_rc/resource_proxy/abstract_resource.rb

@@ -1,7 +1,8 @@
-require 'omf_rc/deferred_process'
+#require 'omf_rc/deferred_process'
 require 'omf_rc/omf_error'
 require 'securerandom'
 require 'hashie'
+require 'monitor'
 
 # OML Measurement Point (MP)
 # This MP is for measurements about messages published by the Resource Proxy
@@ -10,7 +11,7 @@ class OmfRc::ResourceProxy::MPPublished < OML4R::MPBase
   param :time, :type => :double # Time (s) when this message was published
   param :uid, :type => :string # UID for this Resource Proxy
   param :topic, :type => :string # Pubsub topic to publish this message to
-  param :msg_id, :type => :string # Unique ID this message
+  param :mid, :type => :string # Unique ID this message
 end
 
 # OML Measurement Point (MP)
@@ -20,76 +21,85 @@ class OmfRc::ResourceProxy::MPReceived < OML4R::MPBase
   param :time, :type => :double # Time (s) when this message was received
   param :uid, :type => :string # UID for this Resource Proxy
   param :topic, :type => :string # Pubsub topic where this message came from
-  param :msg_id, :type => :string # Unique ID this message
+  param :mid, :type => :string # Unique ID this message
 end
 
 class OmfRc::ResourceProxy::AbstractResource
+  include MonitorMixin
+
   # Time to wait before shutting down event loop, wait for deleting pubsub topics
   DISCONNECT_WAIT = 5
   # Time to wait before releasing resource, wait for deleting pubsub topics
   RELEASE_WAIT = 5
 
+  DEFAULT_CREATION_OPTS = {
+    suppress_create_message: false,
+    create_children_resources: true
+  }
+
   # @!attribute property
   #   @return [String] the resource's internal meta data storage
   attr_accessor :uid, :hrn, :type, :comm, :property
-  attr_reader :opts, :children, :membership
+  attr_reader :opts, :children, :membership, :creation_opts, :membership_topics
 
   # Initialisation
   #
   # @param [Symbol] type resource proxy type
+  #
   # @param [Hash] opts options to be initialised
   # @option opts [String] :uid Unique identifier
   # @option opts [String] :hrn Human readable name
-  # @option opts [String] :dsl Which pubsub DSL to be used for pubsub communication
-  # @option opts [String] :user pubsub user id
-  # @option opts [String] :password pubsub user password
-  # @option opts [String] :server pubsub server domain
-  # @option opts [String] :property A hash for keeping internal state
-  # @option opts [hash] :instrument A hash for keeping instrumentation-related state
-  # @param [Comm] comm communicator instance, pass this to new resource proxy instance if want to use a common communicator instance.
-  def initialize(type, opts = nil, comm = nil)
+  # @option opts [Hash] :property A hash for keeping internal state
+  # @option opts [Hash] :instrument A hash for keeping instrumentation-related state
+  #
+  # @param [Hash] creation_opts options to control the resource creation process
+  # @option creation_opts [Boolean] :suppress_create_message Don't send an initial CREATION.OK Inform message
+  # @option creation_opts [Boolean] :create_children_resources Immediately create 'known' children resources, such as interfaces on nodes
+  #
+  def initialize(type, opts = {}, creation_opts = {}, &creation_callback)
     @opts = Hashie::Mash.new(opts)
+    @creation_opts = Hashie::Mash.new(DEFAULT_CREATION_OPTS.merge(creation_opts))
+
     @type = type
     @uid = @opts.uid || SecureRandom.uuid
-    @hrn = @opts.hrn
+    @hrn = @opts.hrn && @opts.hrn.to_s
+
     @children ||= []
     @membership ||= []
+    @topics = []
+    @membership_topics ||= {}
+
+    # FIXME adding hrn to membership too?
+    #@membership << @hrn if @hrn
 
     @property = @opts.property || Hashie::Mash.new
+    @property.merge!(@opts.except([:uid, :hrn, :property, :instrument]))
 
-    @comm = comm || OmfCommon::Comm.new(@opts.dsl)
-    # Fire when connection to pubsub server established
-    @comm.when_ready do
-      logger.info "CONNECTED: #{@comm.jid.inspect}"
-
-      # Once connection established, create a pubsub topic, then subscribe to it
-      @comm.create_topic(uid) do |s|
-        # Creating topic failed, no point to continue; clean up and disconnect
-        # Otherwise go subscribe to this pubsub topic
-        if s.error?
-          warn "Could not create topic '#{uid}', will shutdown, trying to clean up old topics. Please start it again once it has been shutdown."
-          disconnect
-        else
-          @comm.subscribe(uid)
-        end
+    OmfCommon.comm.subscribe(@hrn ? [@uid, @hrn] : @uid) do |t|
+      if t.id.to_s == @uid
+        @topics << t
       end
-    end
 
-    # Fire when message published
-    @comm.topic_event do |e|
-      e.items.each do |item|
-        process_omf_message(item.payload, e.node)
+      if t.error?
+        warn "Could not create topic '#{uid}', will shutdown, trying to clean up old topics. Please start it again once it has been shutdown."
+        OmfCommon.comm.disconnect()
+      else
+        creation_callback.call(self) if creation_callback
+        copts = { res_id: self.resource_address, hrn: @hrn }.merge(@property)
+        t.inform(:creation_ok, copts, copts)
+
+        t.on_message(nil, @uid) do |imsg|
+          process_omf_message(imsg, t)
+        end
       end
     end
 
-    # Generic pubsub event
-    @comm.pubsub_event do |e|
-      logger.debug "PUBSUB GENERIC EVENT: #{e}"
-    end
+    super()
   end
 
   # If method missing, try the property mash
   def method_missing(method_name, *args)
+    warn "Method missing: '#{method_name}'"
     if (method_name =~ /request_(.+)/)
       property.key?($1) ? property.send($1) : (raise OmfRc::UnknownPropertyError, method_name.to_s)
     elsif (method_name =~ /configure_(.+)/)
@@ -99,57 +109,103 @@ class OmfRc::ResourceProxy::AbstractResource
     end
   end
 
-  def get_binding
-    binding
+  # Overwirte methods to add ghost methods
+  def methods
+    super + property.keys.map { |v| ["configure_#{v}".to_sym, "request_#{v}".to_sym] }.flatten
   end
 
-  # Connect to pubsub server
-  def connect
-    @comm.connect(opts.user, opts.password, opts.server)
+  # Return the public 'routable'  address for this resource
+  #
+  def resource_address()
+    @topics[0].address
+  end
+
+  def get_binding
+    binding
   end
 
   # Try to clean up pubsub topics, and wait for DISCONNECT_WAIT seconds, then shutdown event machine loop
   def disconnect
-    @comm.disconnect(delete_affiliations: true)
-    logger.info "Disconnecting #{hrn}(#{uid}) in #{DISCONNECT_WAIT} seconds"
-    EM.add_timer(DISCONNECT_WAIT) do
-      @comm.disconnect
-    end
+    OmfCommon.comm.disconnect
   end
 
   # Create a new resource in the context of this resource. This resource becomes parent, and newly created resource becomes child
   #
   # @param (see #initialize)
-  def create(type, opts = nil)
+  def create(type, opts = {}, creation_opts = {}, &creation_callback)
     proxy_info = OmfRc::ResourceFactory.proxy_list[type]
     if proxy_info && proxy_info.create_by && !proxy_info.create_by.include?(self.type.to_sym)
       raise StandardError, "Resource #{type} is not designed to be created by #{self.type}"
     end
 
     before_create(type, opts) if respond_to? :before_create
-    new_resource = OmfRc::ResourceFactory.new(type.to_sym, opts, @comm)
+    new_resource = OmfRc::ResourceFactory.create(type.to_sym, opts, creation_opts, &creation_callback)
     after_create(new_resource) if respond_to? :after_create
-    children << new_resource
+
+    self.synchronize do
+      children << new_resource
+    end
     new_resource
   end
 
-  # Release a resource
+  # Release a child resource
+  #
+  # @return [AbstractResource] Relsead child or nil if error
   #
-  def release(resource_id)
-    obj = children.find { |v| v.uid == resource_id }
-    if obj.nil?
-      warn "#{resource_id} does not belong to #{self.uid}(#{self.hrn})"
-      nil
+  def release(res_id)
+    if (child = children.find { |v| v.uid.to_s == res_id.to_s })
+      if child.release_self()
+        self.synchronize do
+          children.delete(child)
+        end
+        child
+      else
+        child = nil
+      end
+      debug "#{child.uid} released"
     else
-      # Release children resource recursively
-      obj.children.each do |c|
-        obj.release(c.uid)
+      debug "#{res_id} does not belong to #{self.uid}(#{self.hrn}) - #{children.map(&:uid).inspect}"
+    end
+    child
+  end
+
+  # Release this resource. Should ONLY be called by parent resource.
+  #
+  # Return true if successful
+  #
+  def release_self
+    # Release children resource recursively
+    children.each do |c|
+      if c.release_self
+        self.synchronize do
+          children.delete(c)
+        end
       end
-      obj.before_release if obj.respond_to? :before_release
+    end
+
+    return false unless children.empty?
 
-      @comm.delete_topic(obj.uid)
-      children.delete(obj)
+    info "Releasing hrn: #{hrn}, uid: #{uid}"
+    self.before_release if self.respond_to? :before_release
+    props = {
+      res_id: resource_address
+    }
+    props[:hrn] = hrn if hrn
+    inform :released, props
+
+    # clean up topics
+    @topics.each do |t|
+      t.unsubscribe
     end
+
+    @membership_topics.each_value do |t|
+      if t.respond_to? :delete_on_message_cbk_by_id
+        t.delete_on_message_cbk_by_id(@uid)
+      end
+      t.unsubscribe
+    end
+
+    true
   end
 
   # Return a list of all properties can be requested and configured
@@ -157,7 +213,7 @@ class OmfRc::ResourceProxy::AbstractResource
   def request_available_properties(*args)
     Hashie::Mash.new(request: [], configure: []).tap do |mash|
       methods.each do |m|
-        mash[$1] << $2.to_sym if m =~ /(request|configure)_(.+)/ && $2 != "available_properties"
+        mash[$1] << $2.to_sym if m =~ /^(request|configure)_(.+)/ && $2 != "available_properties"
       end
     end
   end
@@ -167,6 +223,14 @@ class OmfRc::ResourceProxy::AbstractResource
     uid
   end
 
+  def request_type(*args)
+    type
+  end
+
+  def configure_type(*args)
+    @type = type
+  end
+
   # Make hrn accessible through pubsub interface
   def request_hrn(*args)
     hrn
@@ -174,33 +238,43 @@ class OmfRc::ResourceProxy::AbstractResource
 
   alias_method :request_name, :request_hrn
   alias_method :name, :hrn
-  alias_method :name=, :hrn=
-
-  def request_type(*args)
-    type
-  end
 
   # Make hrn configurable through pubsub interface
   def configure_hrn(hrn)
-    @hrn = hrn
+    self.synchronize do
+      @hrn = hrn
+    end
     @hrn
   end
 
+  alias_method :configure_name, :configure_hrn
+  alias_method :name=, :hrn=
+
   # Make resource part of the group topic, it will overwrite existing membership array
   #
   # @param [String] name of group topic
   # @param [Array] name of group topics
   def configure_membership(*args)
     new_membership = [args[0]].flatten
-    new_membership.each do |n_m|
-      @membership << n_m unless @membership.include?(n_m)
-    end
-    @membership.each do |m|
-      @comm.subscribe(m) do |stanza|
-        if stanza.error?
-          warn "Group #{m} disappeared"
-          EM.next_tick do
-            @membership.delete(m)
+
+    new_membership.each do |new_m|
+      unless @membership.include?(new_m)
+        OmfCommon.comm.subscribe(new_m) do |t|
+          if t.error?
+            warn "Group #{new_m} disappeared"
+            #EM.next_tick do
+            #  @membership.delete(m)
+            #end
+          else
+            self.synchronize do
+              @membership << new_m
+              @membership_topics[new_m] = t
+              self.inform(:status, { membership: @membership }, t)
+            end
+
+            t.on_message(nil, @uid) do |imsg|
+              process_omf_message(imsg, t)
+            end
           end
         end
       end
@@ -219,184 +293,209 @@ class OmfRc::ResourceProxy::AbstractResource
     children.map { |c| Hashie::Mash.new({ uid: c.uid, name: c.hrn }) }
   end
 
-  # Publish an inform message
-  # @param [Symbol] inform_type the type of inform message
-  # @param [Hash | Hashie::Mash | Exception | String] inform_data the type of inform message
-  def inform(inform_type, inform_data)
-    inform_data = Hashie::Mash.new(inform_data) if inform_data.class == Hash
+  # Parse omf message and execute as instructed by the message
+  #
+  # @param [OmfCommon::Message]
+  # @param [OmfCommon::Comm::Topic]
+  def process_omf_message(message, topic)
+    return unless check_guard(message)
 
-    case inform_type
-    when :failed
-      unless inform_data.kind_of? Exception
-        raise ArgumentError, "FAILED message requires an Exception (or MessageProcessError)"
-      end
-    when :created, :released
-      unless inform_data.respond_to?(:resource_id) && !inform_data.resource_id.nil?
-        raise ArgumentError, "CREATED or RELEASED message requires inform_data object respond to resource_id"
-      end
-    when :status
-      unless inform_data.respond_to?(:status) && inform_data.status.kind_of?(Hash)
-        raise ArgumentError, "STATUS message requires a hash represents properties"
-      end
+    unless message.is_a? OmfCommon::Message
+      raise ArgumentError, "Expected OmfCommon::Message, but got '#{message.class}'"
     end
 
-    context_id = inform_data.context_id if inform_data.respond_to? :context_id
-    inform_to = inform_data.inform_to if inform_data.respond_to? :inform_to
-    inform_to ||= self.uid
-
-    inform_message = OmfCommon::Message.inform(inform_type.to_s.upcase, context_id) do |i|
-      case inform_type
-      when :created
-        i.element('resource_id', inform_data.resource_id)
-        i.element('resource_address', inform_data.resource_id)
-      when :status
-        inform_data.status.each_pair { |k, v| i.property(k, v) }
-      when :released
-        i.element('resource_id', inform_data.resource_id)
-      when :error, :warn
-        i.element("reason", (inform_data.message rescue inform_data))
-        logger.__send__(inform_type, (inform_data.message rescue inform_data))
-      when :failed
-        i.element("reason", inform_data.message)
+    unless message.valid?
+      raise StandardError, "Invalid message received: #{pubsub_item_payload}. Please check protocol schema of version #{OmfCommon::PROTOCOL_VERSION}."
+    end
+
+    objects_by_topic(topic.id.to_s).each do |obj|
+      if OmfCommon::Measure.enabled?
+        OmfRc::ResourceProxy::MPReceived.inject(Time.now.to_f, self.uid, topic, message.mid)
       end
+      execute_omf_operation(message, obj, topic)
     end
-    @comm.publish(inform_to, inform_message)
-    OmfRc::ResourceProxy::MPPublished.inject(Time.now.to_f,
-      self.uid, inform_to, inform_message.msg_id) if OmfCommon::Measure.enabled?
   end
 
-  private
+  def execute_omf_operation(message, obj, topic)
+    begin
+      response_h = handle_message(message, obj)
+    rescue Exception => ex
+      err_resp = message.create_inform_reply_message()
+      err_resp[:reason] = ex.to_s
+      error "Encountered exception, returning ERROR message"
+      debug ex.message
+      debug ex.backtrace.join("\n")
+      return inform(:error, err_resp, topic)
+    end
 
-  # Find resource object based on topic name
-  def objects_by_topic(name)
-    if name == uid || membership.include?(name)
-      objs = [self]
-    else
-      objs = children.find_all { |v| v.uid == name || v.membership.include?(name)}
+    case message.operation
+    #when :create
+    #  inform(:creation_ok, response_h, topic)
+    when :request, :configure
+      inform(:status, response_h, topic)
+    when :release
+      OmfCommon.eventloop.after(RELEASE_WAIT) do
+        inform(:released, response_h, topic) if response_h[:res_id]
+      end
     end
   end
 
-  def inform_to_address(obj, publish_to = nil)
-    publish_to || obj.uid
+  # Handling all messages, then delegate them to individual handler
+  def handle_message(message, obj)
+    response = message.create_inform_reply_message()
+    response.replyto replyto_address(obj, message.replyto)
+
+    case message.operation
+    when :create
+      handle_create_message(message, obj, response)
+    when :request
+      response = handle_request_message(message, obj, response)
+    when :configure
+      handle_configure_message(message, obj, response)
+    when :release
+      handle_release_message(message, obj, response)
+    when :inform
+      nil # We really don't care about inform messages which created from here
+    else
+      raise StandardError, <<-ERROR
+            Invalid message received (Unknown OMF operation #{message.operation}): #{message}.
+            Please check protocol schema of version #{OmfCommon::PROTOCOL_VERSION}.
+      ERROR
+    end
+    response
   end
 
-  # Parse omf message and execute as instructed by the message
-  #
-  def process_omf_message(pubsub_item_payload, topic)
-    message = OmfCommon::Message.parse(pubsub_item_payload)
+  def handle_create_message(message, obj, response)
+    new_name = message[:name] || message[:hrn]
+    new_opts = message.properties.merge({ hrn: new_name })
+    new_obj = obj.create(message[:type], new_opts) do |new_obj|
+      begin
+        response[:res_id] = new_obj.resource_address
 
-    unless message.valid?
-      raise StandardError, "Invalid message received: #{pubsub_item_payload}. Please check protocol schema of version #{OmfCommon::PROTOCOL_VERSION}."
+        exclude = [:type, :hrn, :name]
+        message.each_property do |key, value|
+          unless exclude.include?(key)
+            method_name = "configure_#{key}"
+            response[key] = new_obj.__send__(method_name, value)
+          end
+        end
+        response[:hrn] = new_obj.hrn
+        response[:uid] = new_obj.uid
+        response[:type] = new_obj.type
+
+        new_obj.after_initial_configured if new_obj.respond_to? :after_initial_configured
+
+        # self here is the parent
+        self.inform(:creation_ok, response)
+      rescue Exception => ex
+        err_resp = message.create_inform_reply_message()
+        err_resp[:reason] = ex.to_s
+        error "Encountered exception, returning ERROR message"
+        debug ex.message
+        debug ex.backtrace.join("\n")
+        return self.inform(:error, err_resp)
+      end
     end
+  end
 
-    objects_by_topic(topic).each do |obj|
-      OmfRc::ResourceProxy::MPReceived.inject(Time.now.to_f,
-        self.uid, topic, message.msg_id) if OmfCommon::Measure.enabled?
-      execute_omf_operation(message, obj)
+  def handle_configure_message(message, obj, response)
+    message.each_property do |key, value|
+      method_name =  "#{message.operation.to_s}_#{key}"
+      p_value = message[key]
+      response[key] ||= obj.__send__(method_name, p_value)
     end
   end
 
-  def execute_omf_operation(message, obj)
-    dp = OmfRc::DeferredProcess.new
-
-    # When successfully executed
-    dp.callback do |response|
-      response = Hashie::Mash.new(response)
-      case response.operation
-      when :create
-        new_uid = response.resource_id
-        @comm.create_topic(new_uid) do
-          @comm.subscribe(new_uid) do
-            inform(:created, response)
-          end
-        end
-      when :request, :configure
-        inform(:status, response)
-      when :release
-        EM.add_timer(RELEASE_WAIT) do
-          inform(:released, response)
-        end
+  def handle_request_message(message, obj, response)
+    allowed_properties = obj.request_available_properties.request - [:message]
+
+    have_unbound = false
+
+    message.each_unbound_request_property do |name|
+      puts "NAME>> #{name.inspect}"
+
+      unless allowed_properties.include?(name.to_sym)
+        raise ArgumentError, "Unknown 'requestable' property '#{name}'. Allowed properties are: #{allowed_properties.join(', ')}"
       end
+      method_name = "request_#{name}"
+      response[name] = obj.__send__(method_name)
+      have_unbound = true
+    end
+    unless have_unbound
+      # return ALL properties
+      allowed_properties.each do |name|
+        method_name = "request_#{name}"
+        response[name] = obj.__send__(method_name)
+      end
+    end
+    response
+  end
+
+  def handle_release_message(message, obj, response)
+    res_id = message.res_id
+    released_obj = obj.release(res_id)
+    # TODO: Under what circumstances would 'realease_obj' be NIL
+    #
+    # When release message send to a group, for bulk releasing,
+    # the proxy might not be aware of a res_id it received
+    response[:res_id] = released_obj.resource_address if released_obj
+    response
+  end
+
+
+  # Publish an inform message
+  # @param [Symbol] itype the type of inform message
+  # @param [Hash | Hashie::Mash | Exception | String] inform_data the type of inform message
+  def inform(itype, inform_data, topic = nil)
+    topic ||= @topics.first
+
+    if inform_data.is_a? Hash
+      inform_data = Hashie::Mash.new(inform_data) if inform_data.class == Hash
+      message = OmfCommon::Message.create_inform_message(itype.to_s.upcase, inform_data.dup)
+    else
+      message = inform_data
     end
 
-    # When failed
-    dp.errback do |e|
-      inform(:failed, e)
+    message.itype = itype
+    unless itype == :released
+      message[:uid] ||= self.uid
+      message[:type] ||= self.type
+      message[:hrn] ||= self.hrn
     end
 
-    # Fire the process
-    dp.fire do
-      begin
-        default_response = {
-          operation: message.operation,
-          context_id: message.msg_id,
-          inform_to: inform_to_address(obj, message.publish_to)
-        }
+    topic.publish(message)
 
-        guard = message.read_element("guard").first
+    OmfRc::ResourceProxy::MPPublished.inject(Time.now.to_f,
+      self.uid, replyto, inform_message.mid) if OmfCommon::Measure.enabled?
+  end
 
-        unless guard.nil? || guard.element_children.empty?
-          guard_check = guard.element_children.all? do |g|
-            obj.__send__("request_#{g.attr('key')}") == g.content.ducktype
-          end
-          next nil unless guard_check
-        end
+  private
 
-        case message.operation
-        when :create
-          new_name = message.read_property(:name) || message.read_property(:hrn)
-          new_opts = opts.dup.merge(uid: nil, hrn: new_name)
-          new_obj = obj.create(message.read_property(:type), new_opts)
-          message.each_property do |p|
-            unless %w(type hrn name).include?(p.attr('key'))
-              method_name = "configure_#{p.attr('key')}"
-              p_value = message.read_property(p.attr('key'), new_obj.get_binding)
-              new_obj.__send__(method_name, p_value)
-            end
-          end
-          new_obj.after_initial_configured if new_obj.respond_to? :after_initial_configured
-          default_response.merge(resource_id: new_obj.uid)
-        when :request, :configure
-          result = Hashie::Mash.new.tap do |mash|
-            properties = message.read_element("property")
-            if message.operation == :request && properties.empty?
-              obj.request_available_properties.request.each do |r_p|
-                method_name = "request_#{r_p.to_s}"
-                mash[r_p] ||= obj.__send__(method_name)
-              end
-            else
-              properties.each do |p|
-                method_name =  "#{message.operation.to_s}_#{p.attr('key')}"
-                p_value = message.read_property(p.attr('key'), obj.get_binding)
-                mash[p.attr('key')] ||= obj.__send__(method_name, p_value)
-              end
-            end
-          end
-          # Always return uid
-          result.uid = obj.uid
-          default_response.merge(status: result)
-        when :release
-          resource_id = message.resource_id
-          released_obj = obj.release(resource_id)
-          released_obj ? default_response.merge(resource_id: released_obj.uid) : nil
-        when :inform
-          nil # We really don't care about inform messages which created from here
-        else
-          raise StandardError, <<-ERROR
-            Invalid message received (Unknown OMF operation #{message.operation}): #{pubsub_item_payload}.
-            Please check protocol schema of version #{OmfCommon::PROTOCOL_VERSION}.
-          ERROR
-        end
-      rescue => e
-        if (e.kind_of? OmfRc::UnknownPropertyError) && (message.operation == :configure || message.operation == :request)
-          msg = "Cannot #{message.operation} unknown property '#{e.message}' for resource '#{obj.type}'. Original message fragment: " +
-            "'#{message.read_element("property")}'"
-          logger.warn msg
-          raise OmfRc::MessageProcessError.new(message.context_id, inform_to_address(obj, message.publish_to), msg)
+  # Find resource object based on topic name
+  def objects_by_topic(name)
+    if name == uid || membership.include?(name)
+      objs = [self]
+    else
+      objs = children.find_all { |v| v.uid == name || v.membership.include?(name)}
+    end
+  end
+
+  def replyto_address(obj, replyto = nil)
+    replyto || obj.uid
+  end
+
+  def check_guard(message)
+    guard = message.guard
+
+    if guard.nil? || guard.empty?
+      return true
+    else
+      guard.keys.all? do |key|
+        value = self.__send__("request_#{key}")
+        if value.kind_of? Symbol
+          value.to_s == guard[key].to_s
         else
-          logger.error e.message
-          logger.error e.backtrace.join("\n")
-          raise OmfRc::MessageProcessError.new(message.context_id, inform_to_address(obj, message.publish_to), e.message)
+          value == guard[key]
         end
       end
     end