omf_rc 6.0.0.pre.6 → 6.0.0.pre.7

data/bin/omf_rc

@@ -10,42 +10,50 @@ options = {
 }
 
 executable_name = File.basename($PROGRAM_NAME)
+oml_enabled = false
 
-option_parser = OptionParser.new do |opts|
-  opts.banner = "usage: #{executable_name} [options]"
+begin
+  oml_enabled = OML4R::init(ARGV, :appName => executable_name) do |opts|
+    opts.banner = "usage: #{executable_name} [options]"
 
-  opts.on("-u USER", "Username") do |user|
-    options[:user] = user
-  end
+    opts.on("-u USER", "Username") do |user|
+      options[:user] = user
+    end
 
-  opts.on("-p PASSWORD", "Password") do |password|
-    options[:password] = password
-  end
+    opts.on("-p PASSWORD", "Password") do |password|
+      options[:password] = password
+    end
 
-  opts.on("-s SERVER", "XMPP server") do |server|
-    options[:server] = server
-  end
+    opts.on("-s SERVER", "PubSub server") do |server|
+      options[:server] = server
+    end
 
-  opts.on("-t TOPIC", "PubSub topic to create, also becomes the uid of the resource, default to hostname") do |topic|
-    options[:uid] = topic
-  end
+    opts.on("-t TOPIC", "PubSub topic to create, also becomes the uid of the resource, default to hostname") do |topic|
+      options[:uid] = topic
+    end
 
-  opts.on("-d", "--debug", "Debug mode") do
-    options[:debug] = true
+    opts.on("-d", "--debug", "Debug mode") do
+      options[:debug] = true
+    end
   end
-end
-
-begin
-  option_parser.parse!
 rescue => e
-  puts e.message
-  puts ""
-  puts option_parser.help
-  exit(1)
+  # Right now OML4R does not raise proper exceptions :(
+  # OML4R requires --oml-noop to be set if we want to run without doing any
+  # measurements... this is too restrictive here, we want to run without OML
+  # if no OML parameters were set and this even if --oml-noop is not set. 
+  if e.message.include?('OML4R: Missing values for parameters :expID ')
+    puts "Warning: Missing some OML options to instrument this RC, so it will "+
+      "run without instrumentation. (see --oml-help)"
+  else
+    puts e.message
+    exit(1)
+  end
 end
 
-unless options[:server] && options[:user] && options[:server]
-  puts option_parser.help
+OmfCommon::Measure.enable if oml_enabled
+
+unless options[:server] && options[:user] && options[:password]
+  puts "Error: Missing parameters to connect to a PubSub Server (see --help)"
   exit(1)
 end
 

data/config/omf_rc.yml

@@ -5,35 +5,35 @@
 #
 ---
 :rcontroller:
-  # Communication settings 
+  # Communication settings
   :communicator:
-    
-    # Interface to the control network from which this resource can be 
+
+    # Interface to the control network from which this resource can be
     # controlled & managed
     :control_if: 'control'
 
-    # set this to true or false if you want to enable or disable signature checks and message signing                                       
+    # set this to true or false if you want to enable or disable signature checks and message signing
     :authenticate_messages: false
     # your RSA/DSA SSH private key file
     :private_key: '/etc/omf-resctl-5.4/id_rsa'
     # directory holding the public keys of your OMF peers
     :public_key_dir: '/etc/omf-resctl-5.4/peer_keys'
-    
+
     :type: 'xmpp'
     :xmpp:
       # Address of the PubSub server to use as gateway for PubSub communication
       :pubsub_gateway: 'norbit.npc.nicta.com.au'
       #:pubsub_port: 5222
       # Address of the PubSub server which host the communication for my slice
-      # Leave this commented if the pubsub groups for this slice are hosted on 
+      # Leave this commented if the pubsub groups for this slice are hosted on
       # the same server as the 'pubsub_gateway'
       #:pubsub_domain: 10.0.0.200
       # The following 'home_pubsub_user' and 'home_pubsub_pwd' are optional
       # RC will create a unique user/pwd for itself if this is not provided
       # In a typical OMF install, you should not uncomment these lines
-      # (do so only if you need to manually set user/password for 
+      # (do so only if you need to manually set user/password for
       # your client to connect to your pubsub server)
-      #:pubsub_user: 'my_RC_name' 
+      #:pubsub_user: 'my_RC_name'
       #:pubsub_pwd: 'my_RC_password'
       # set this to "true" if you have a DNS SRV record pointing to the
       # real pubsub server hostname
@@ -45,7 +45,7 @@
     # Name (i.e. unique HRN ID) of this resource
     # Or this could also be passed as a command line parameter "--name"
     # This is either a fully defined string, e.g. "my_resource_name"
-    # Or a string for which some values will be replaced by the running RC, 
+    # Or a string for which some values will be replaced by the running RC,
     # currently we support the values: %hostname%, %macaddr%, %fqdn%
     # For example, if you use "some_prefix.%hostname%.some_suffix"
     # Then if your hostname is 'node1', then your RC name will be
@@ -56,7 +56,7 @@
 
     # Name (i.e. unique HRN ID) of the slice to which this resource is assigned
     :slice: default_slice
-    
+
     # shrink the filesystem size before saving an image
     # grow the filesystem to match the disk size after loading an image
     # enabling this may slow down load/save significantly

data/lib/omf_rc/{message_process_error.rb → omf_error.rb}

@@ -9,3 +9,11 @@ class OmfRc::MessageProcessError < StandardError
     super(msg)
   end
 end
+
+# No method error that caused by configure/request unknown property
+#
+class OmfRc::UnknownPropertyError < NoMethodError
+  def initialize(msg = nil)
+    super(msg)
+  end
+end

data/lib/omf_rc/resource_factory.rb

@@ -30,6 +30,10 @@ class OmfRc::ResourceFactory
       resource = OmfRc::ResourceProxy::AbstractResource.new(type, opts, comm)
       # Then extend this instance with relevant module identified by type
       resource.extend("OmfRc::ResourceProxy::#{type.camelize}".constantize)
+      # Initiate property hash
+      resource.methods.each do |m|
+        resource.__send__(m) if m =~ /def_property_(.+)/
+      end
       # Execute resource before_ready hook if any
       resource.before_ready if resource.respond_to? :before_ready
       resource

data/lib/omf_rc/resource_proxy/abstract_resource.rb

@@ -1,8 +1,28 @@
 require 'omf_rc/deferred_process'
-require 'omf_rc/message_process_error'
+require 'omf_rc/omf_error'
 require 'securerandom'
 require 'hashie'
 
+# OML Measurement Point (MP)
+# This MP is for measurements about messages published by the Resource Proxy
+class OmfRc::ResourceProxy::MPPublished < OML4R::MPBase
+  name :proxy_published
+  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
+end
+
+# OML Measurement Point (MP)
+# This MP is for measurements about messages received by the Resource Proxy
+class OmfRc::ResourceProxy::MPReceived < OML4R::MPBase
+  name :proxy_received
+  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
+end
+
 class OmfRc::ResourceProxy::AbstractResource
   # Time to wait before shutting down event loop, wait for deleting pubsub topics
   DISCONNECT_WAIT = 5
@@ -12,7 +32,7 @@ class OmfRc::ResourceProxy::AbstractResource
   # @!attribute property
   #   @return [String] the resource's internal meta data storage
   attr_accessor :uid, :hrn, :type, :comm, :property
-  attr_reader :opts, :children
+  attr_reader :opts, :children, :membership
 
   # Initialisation
   #
@@ -25,6 +45,7 @@ class OmfRc::ResourceProxy::AbstractResource
   # @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)
     @opts = Hashie::Mash.new(opts)
@@ -32,6 +53,7 @@ class OmfRc::ResourceProxy::AbstractResource
     @uid = @opts.uid || SecureRandom.uuid
     @hrn = @opts.hrn
     @children ||= []
+    @membership ||= []
 
     @property = @opts.property || Hashie::Mash.new
 
@@ -64,9 +86,9 @@ class OmfRc::ResourceProxy::AbstractResource
   # If method missing, try the property mash
   def method_missing(method_name, *args)
     if (method_name =~ /request_(.+)/)
-      property.send($1) || super
+      property.key?($1) ? property.send($1) : (raise OmfRc::UnknownPropertyError)
     elsif (method_name =~ /configure_(.+)/)
-      property.send($1) ? property.send("[]=", $1, *args) : super
+      property.key?($1) ? property.send("[]=", $1, *args) : (raise OmfRc::UnknownPropertyError)
     else
       super
     end
@@ -149,16 +171,26 @@ class OmfRc::ResourceProxy::AbstractResource
   # Make hrn configurable through pubsub interface
   def configure_hrn(hrn)
     @hrn = hrn
+    @hrn
+  end
+
+  # 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
+    @membership = new_membership
+    @membership.each do |m|
+      @comm.subscribe(m)
+    end
+    @membership
   end
 
   # Request child resources
-  # @return [Mash] child resource mash with uid and hrn
+  # @return [Hashie::Mash] child resource mash with uid and hrn
   def request_child_resources(*args)
-    Hashie::Mash.new.tap do |mash|
-      children.each do |c|
-        mash[c.uid] ||= c.hrn
-      end
-    end
+    children.map { |c| Hashie::Mash.new({ uid: c.uid, name: c.hrn }) }
   end
 
   # Publish an inform message
@@ -203,15 +235,45 @@ class OmfRc::ResourceProxy::AbstractResource
       end
     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
 
+  # 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 inform_to_address(obj, publish_to = nil)
+    publish_to || obj.uid
+  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)
+
+    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).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)
+    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
@@ -231,68 +293,69 @@ class OmfRc::ResourceProxy::AbstractResource
       end
     end
 
+    # When failed
     dp.errback do |e|
       inform(:failed, e)
     end
 
+    # Fire the process
     dp.fire do
-      message = OmfCommon::Message.parse(pubsub_item_payload)
-      # Get the context id, which will be included when informing
-      context_id = message.read_content("context_id")
-
-      obj = topic == uid ? self : children.find { |v| v.uid == topic }
-
       begin
-        raise "Resource disappeard #{topic}" if obj.nil?
+        default_response = {
+          operation: message.operation,
+          context_id: message.context_id,
+          inform_to: inform_to_address(obj, message.publish_to)
+        }
 
         case message.operation
         when :create
-          create_opts = opts.dup
-          create_opts.uid = nil
-          result = obj.create(message.read_property(:type), create_opts)
+          new_opts = opts.dup.merge(uid: nil)
+          new_obj = obj.create(message.read_property(:type), new_opts)
           message.each_property do |p|
             unless p.attr('key') == 'type'
-              method_name =  "configure_#{p.attr('key')}"
-              result.__send__(method_name, message.read_property(p.attr('key')))
-            end
-          end
-          result.after_initial_configured if result.respond_to? :after_initial_configured
-          { operation: :create, resource_id: result.uid, context_id: context_id, inform_to: uid }
-        when :request
-          result = Hashie::Mash.new.tap do |mash|
-            message.read_element("//property").each do |p|
-              method_name =  "request_#{p.attr('key')}"
-              mash[p.attr('key')] ||= obj.__send__(method_name, message.read_property(p.attr('key')))
+              method_name = "configure_#{p.attr('key')}"
+              new_obj.__send__(method_name, message.read_property(p.attr('key')))
             end
           end
-          { operation: :request, status: result, context_id: context_id, inform_to: obj.uid }
-        when :configure
+          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|
-            message.read_element("//property").each do |p|
-              method_name =  "configure_#{p.attr('key')}"
-              mash[p.attr('key')] ||= obj.__send__(method_name, message.read_property(p.attr('key')))
+            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')}"
+                mash[p.attr('key')] ||= obj.__send__(method_name, message.read_property(p.attr('key')))
+              end
             end
           end
-          { operation: :configure, status: result, context_id: context_id, inform_to: obj.uid }
+          default_response.merge(status: result)
         when :release
           resource_id = message.resource_id
-          { operation: :release, resource_id: obj.release(resource_id).uid, context_id: context_id, inform_to: obj.uid }
+          default_response.merge(resource_id: obj.release(resource_id).uid)
         when :inform
-          # We really don't care about inform messages which created from here
-          nil
+          nil # We really don't care about inform messages which created from here
         else
-          raise "Unknown OMF operation #{message.operation}"
+          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? NoMethodError) && (message.operation == :configure || message.operation == :request)
+        if (e.kind_of? OmfRc::UnknownPropertyError) && (message.operation == :configure || message.operation == :request)
           msg = "Cannot #{message.operation} unknown property "+
             "'#{message.read_element("//property")}' for resource '#{type}'"
           logger.warn msg
-          raise OmfRc::MessageProcessError.new(context_id, obj.uid, msg)
+          raise OmfRc::MessageProcessError.new(message.context_id, inform_to_address(obj, message.publish_to), msg)
         else
           logger.error e.message
           logger.error e.backtrace.join("\n")
-          raise OmfRc::MessageProcessError.new(context_id, obj.uid, e.message)
+          raise OmfRc::MessageProcessError.new(message.context_id, inform_to_address(obj, message.publish_to), e.message)
         end
       end
     end