omf_rc 6.0.0.pre.5 → 6.0.0.pre.6

data/Rakefile

@@ -8,9 +8,3 @@ Rake::TestTask.new do |t|
   t.pattern = "test/**/*_spec.rb"
   t.verbose = true
 end
-
-Rake::TestTask.new(:integration) do |t|
-  t.libs << 'integration_test'
-  t.pattern = "integration_test/**/*_spec.rb"
-  t.verbose = true
-end

data/bin/omf_rc

@@ -6,7 +6,7 @@ require 'omf_rc/resource_factory'
 $stdout.sync = true
 
 options = {
-  uid: 'interlagos'
+  uid: `hostname`.chomp
 }
 
 executable_name = File.basename($PROGRAM_NAME)
@@ -26,7 +26,7 @@ option_parser = OptionParser.new do |opts|
     options[:server] = server
   end
 
-  opts.on("-t TOPIC", "PubSub topic to create, also becomes the uid of the resource") do |topic|
+  opts.on("-t TOPIC", "PubSub topic to create, also becomes the uid of the resource, default to hostname") do |topic|
     options[:uid] = topic
   end
 

data/lib/omf_rc/resource_factory.rb

@@ -7,7 +7,7 @@ require 'omf_rc/resource_proxy/abstract_resource'
 #
 class OmfRc::ResourceFactory
   # List of registered resource proxies
-  @@proxy_list = []
+  @@proxy_list = Hashie::Mash.new
 
   # By default, we use xmpp dsl, which based on blather
   DEFAULT_OPTS = {
@@ -21,7 +21,9 @@ class OmfRc::ResourceFactory
     #
     # @see OmfRc::ResourceProxy::AbstractResource
     def new(type, opts = nil, comm = nil, &block)
-      raise ArgumentError, "Resource type not found: #{type.to_s}" unless @@proxy_list.include?(type)
+      unless @@proxy_list.include?(type)
+        raise ArgumentError, "Resource type not found: #{type.to_s}" unless @@proxy_list.include?(type)
+      end
       type = type.to_s
       opts = opts ? DEFAULT_OPTS.merge(opts) : DEFAULT_OPTS
       # Create a new instance of abstract resource
@@ -39,8 +41,12 @@ class OmfRc::ResourceFactory
     end
 
     # Add a proxy to the list
-    def register_proxy(proxy)
-      @@proxy_list << proxy unless @@proxy_list.include?(proxy)
+    def register_proxy(proxy_opts)
+      if @@proxy_list.has_key? proxy_opts[:name]
+        raise StandardError, "Resource has been registered already"
+      else
+        @@proxy_list.update(proxy_opts)
+      end
     end
 
     # Require files from default resource proxy library folder

data/lib/omf_rc/resource_proxy/abstract_resource.rb

@@ -12,7 +12,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, :host
+  attr_reader :opts, :children
 
   # Initialisation
   #
@@ -32,20 +32,19 @@ class OmfRc::ResourceProxy::AbstractResource
     @uid = @opts.uid || SecureRandom.uuid
     @hrn = @opts.hrn
     @children ||= []
-    @host = nil
+
     @property = @opts.property || Hashie::Mash.new
 
     @comm = comm || OmfCommon::Comm.new(@opts.dsl)
     # Fire when connection to pubsub server established
     @comm.when_ready do
       logger.info "CONNECTED: #{@comm.jid.inspect}"
-      @host = @comm.jid.domain
 
       # Once connection established, create a pubsub topic, then subscribe to it
-      @comm.create_topic(uid, host) do |s|
+      @comm.create_topic(uid) do |s|
         # Creating topic failed, no point to continue; clean up and disconnect
         # Otherwise go subscribe to this pubsub topic
-        s.error? ? disconnect : @comm.subscribe(uid, host)
+        s.error? ? disconnect : @comm.subscribe(uid)
       end
     end
 
@@ -62,6 +61,17 @@ class OmfRc::ResourceProxy::AbstractResource
     end
   end
 
+  # If method missing, try the property mash
+  def method_missing(method_name, *args)
+    if (method_name =~ /request_(.+)/)
+      property.send($1) || super
+    elsif (method_name =~ /configure_(.+)/)
+      property.send($1) ? property.send("[]=", $1, *args) : super
+    else
+      super
+    end
+  end
+
   # Connect to pubsub server
   def connect
     @comm.connect(opts.user, opts.password, opts.server)
@@ -69,11 +79,11 @@ class OmfRc::ResourceProxy::AbstractResource
 
   # Try to clean up pubsub topics, and wait for DISCONNECT_WAIT seconds, then shutdown event machine loop
   def disconnect
-    @comm.affiliations(host) do |a|
+    @comm.affiliations do |a|
       my_pubsub_topics = a[:owner] ? a[:owner].size : 0
       if my_pubsub_topics > 0
         logger.info "Cleaning #{my_pubsub_topics} pubsub topic(s)"
-        a[:owner].each { |topic| @comm.delete_topic(topic, host) }
+        a[:owner].each { |topic| @comm.delete_topic(topic) }
       else
         logger.info "Disconnecting now"
         @comm.disconnect
@@ -89,27 +99,36 @@ class OmfRc::ResourceProxy::AbstractResource
   #
   # @param (see #initialize)
   def create(type, opts = nil)
-    before_create if respond_to? :before_create
+    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)
+    after_create(new_resource) if respond_to? :after_create
     children << new_resource
     new_resource
   end
 
   # Release a resource
   #
-  def release
-    pubsub_topics_left = []
-    children.each do |c|
-      c.before_release if c.respond_to? :before_release
-      pubsub_topics_left << c.uid
-    end.clear
-    before_release if respond_to? :before_release
-    pubsub_topics_left
+  def release(resource_id)
+    obj = children.find { |v| v.uid == resource_id }
+    raise StandardError, "Resource #{resource_id} could not be found" if obj.nil?
+
+    # Release children resource recursively
+    obj.children.each do |c|
+      obj.release(c.uid)
+    end
+    obj.before_release if obj.respond_to? :before_release
+
+    children.delete(obj)
   end
 
   # Return a list of all properties can be requested and configured
   #
-  def request_available_properties
+  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"
@@ -118,12 +137,12 @@ class OmfRc::ResourceProxy::AbstractResource
   end
 
   # Make uid accessible through pubsub interface
-  def request_uid
+  def request_uid(*args)
     uid
   end
 
   # Make hrn accessible through pubsub interface
-  def request_hrn
+  def request_hrn(*args)
     hrn
   end
 
@@ -134,7 +153,7 @@ class OmfRc::ResourceProxy::AbstractResource
 
   # Request child resources
   # @return [Mash] child resource mash with uid and hrn
-  def request_child_resources
+  def request_child_resources(*args)
     Hashie::Mash.new.tap do |mash|
       children.each do |c|
         mash[c.uid] ||= c.hrn
@@ -142,61 +161,78 @@ class OmfRc::ResourceProxy::AbstractResource
     end
   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
+
+    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
+    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)
+      end
+    end
+    @comm.publish(inform_to, inform_message)
+  end
+
+  private
+
   # Parse omf message and execute as instructed by the message
   #
   def process_omf_message(pubsub_item_payload, topic)
     dp = OmfRc::DeferredProcess.new
 
-    dp.callback do |end_result|
-      if end_result
-        case end_result[:operation]
-        when :create
-          new_uid = end_result[:result]
-          @comm.create_topic(new_uid, host) do
-            @comm.subscribe(new_uid, host) do
-              inform_msg = OmfCommon::Message.inform(end_result[:context_id], 'CREATED') do |i|
-                i.element('resource_id', new_uid)
-                i.element('resource_address', new_uid)
-              end
-              @comm.publish(end_result[:inform_to], inform_msg, host)
-            end
-          end
-        when :request
-          inform_msg = OmfCommon::Message.inform(end_result[:context_id], 'STATUS') do |i|
-            end_result[:result].each_pair do |k, v|
-              i.property(k, v)
-            end
-          end
-          @comm.publish(end_result[:inform_to], inform_msg, host)
-
-        when :configure
-          inform_msg = OmfCommon::Message.inform(end_result[:context_id], 'STATUS') do |i|
-            end_result[:result].each_pair do |k, v|
-              i.property(k, v)
-            end
-          end
-          @comm.publish(end_result[:inform_to], inform_msg, host)
-        when :release
-          inform_msg = OmfCommon::Message.inform(end_result[:context_id], 'RELEASED') do |i|
-            i.element('resource_id', end_result[:inform_to])
-          end
-
-          end_result[:result].each do |n|
-            @comm.delete_topic(n, host)
-          end
-
-          EM.add_timer(RELEASE_WAIT) do
-            @comm.publish(end_result[:inform_to], inform_msg, host)
+    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
       end
     end
 
     dp.errback do |e|
-      inform_msg = OmfCommon::Message.inform(e.context_id, 'FAILED') do |i|
-        i.element("error_message", e.message)
-      end
-      @comm.publish(e.inform_to, inform_msg, host)
+      inform(:failed, e)
     end
 
     dp.fire do
@@ -214,35 +250,33 @@ class OmfRc::ResourceProxy::AbstractResource
           create_opts = opts.dup
           create_opts.uid = nil
           result = obj.create(message.read_property(:type), create_opts)
-          message.read_element("//property").each do |p|
+          message.each_property do |p|
             unless p.attr('key') == 'type'
               method_name =  "configure_#{p.attr('key')}"
-              result.send(method_name, p.content) if result.respond_to? method_name
+              result.__send__(method_name, message.read_property(p.attr('key')))
             end
           end
-          { operation: :create, result: result.uid, context_id: context_id, inform_to: uid }
+          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')}"
-              if obj.respond_to? method_name
-                mash[p.attr('key')] ||= obj.send(method_name)
-              end
+              mash[p.attr('key')] ||= obj.__send__(method_name, message.read_property(p.attr('key')))
             end
           end
-          { operation: :request, result: result, context_id: context_id, inform_to: obj.uid }
+          { operation: :request, status: result, context_id: context_id, inform_to: obj.uid }
         when :configure
           result = Hashie::Mash.new.tap do |mash|
             message.read_element("//property").each do |p|
               method_name =  "configure_#{p.attr('key')}"
-              if obj.respond_to? method_name
-                mash[p.attr('key')] ||= obj.send(method_name, p.content)
-              end
+              mash[p.attr('key')] ||= obj.__send__(method_name, message.read_property(p.attr('key')))
             end
           end
-          { operation: :configure, result: result, context_id: context_id, inform_to: obj.uid }
+          { operation: :configure, status: result, context_id: context_id, inform_to: obj.uid }
         when :release
-          { operation: :release, result: obj.release, context_id: context_id, inform_to: obj.uid }
+          resource_id = message.resource_id
+          { operation: :release, resource_id: obj.release(resource_id).uid, context_id: context_id, inform_to: obj.uid }
         when :inform
           # We really don't care about inform messages which created from here
           nil
@@ -250,9 +284,16 @@ class OmfRc::ResourceProxy::AbstractResource
           raise "Unknown OMF operation #{message.operation}"
         end
       rescue => e
-        logger.error e.message
-        logger.error e.backtrace.join("\n")
-        raise OmfRc::MessageProcessError.new(context_id, obj.uid, e.message)
+        if (e.kind_of? NoMethodError) && (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)
+        else
+          logger.error e.message
+          logger.error e.backtrace.join("\n")
+          raise OmfRc::MessageProcessError.new(context_id, obj.uid, e.message)
+        end
       end
     end
   end