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

data/lib/omf_common/comm.rb

@@ -1,65 +1,132 @@
-require 'omf_common/dsl/xmpp'
-require 'omf_common/dsl/xmpp_mp'
-
+require 'omf_common/comm/topic'
 
 module OmfCommon
   # PubSub communication class, can be extended with different implementations
   class Comm
-    attr_accessor :published_messages
 
-    def initialize(pubsub_implementation)
-      @published_messages = []
-      self.extend("OmfCommon::DSL::#{pubsub_implementation.to_s.camelize}".constantize)
-    end
+    @@providers = {
+      xmpp: {
+        require: 'omf_common/comm/xmpp/communicator',
+        constructor: 'OmfCommon::Comm::XMPP::Communicator',
+        message_provider: {
+          type: :xml
+        }
+      },
+      amqp: {
+        require: 'omf_common/comm/amqp/amqp_communicator',
+        constructor: 'OmfCommon::Comm::AMQP::Communicator',
+        message_provider: {
+          type: :json
+        }
+      },
+      local: {
+        require: 'omf_common/comm/local/local_communicator',
+        constructor: 'OmfCommon::Comm::Local::Communicator',
+        message_provider: {
+          type: :json
+        }
+      }
+    }
+    @@instance = nil
 
-    # 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
-          else
-            Message.send(m_name)
+    #
+    # opts:
+    #   :type - pre installed comms provider
+    #   :provider - custom provider (opts)
+    #     :require - gem to load first (opts)
+    #     :constructor - Class implementing provider
+    #
+    def self.init(opts)
+      if @@instance
+        raise "Comms layer already initialised"
+      end
+      unless provider = opts[:provider]
+        unless type = opts[:type]
+          if url = opts[:url]
+            type = url.split(':')[0].to_sym
           end
+        end
+        provider = @@providers[type]
+      end
+      unless provider
+        raise "Missing Comm provider declaration. Either define 'type', 'provider', or 'url'"
+      end
 
-        OmfCommon::TopicMessage.new(message, self)
+      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)
+      else
+        raise "Missing communicator creation info - :constructor"
       end
+      @@instance = inst
+      Message.init(provider[:message_provider])
+      inst.init(opts)
     end
 
-    %w(created status released failed).each do |inform_type|
-      define_method("on_#{inform_type}_message") do |*args, &message_block|
-        msg_id = args[0].msg_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 &&
-            (msg_id ? (omf_message.context_id == msg_id) : true)
+    def self.instance
+      @@instance
+    end
+
+    # Initialize comms layer
+    #
+    def init(opts = {})
+      raise "Not implemented"
+    end
+
+    # Shut down comms layer
+    def disconnect(opts = {})
+      raise "Not implemented"
+    end
+
+    def on_connected(&block)
+      raise "Not implemented"
+    end
+
+    # Create a new pubsub topic with additional configuration
+    #
+    # @param [String] topic Pubsub topic name
+    def create_topic(topic, opts = {})
+      raise "Not implemented"
+    end
+
+    # Delete a pubsub topic
+    #
+    # @param [String] topic Pubsub topic name
+    def delete_topic(topic, &block)
+      raise "Not implemented"
+    end
+
+    # Subscribe to a pubsub topic
+    #
+    # @param [String, Array] topic_name Pubsub topic name
+    # @param [Hash] opts
+    # @option opts [Boolean] :create_if_non_existent create the topic if non-existent, use this option with caution
+    #
+    def subscribe(topic_name, opts = {}, &block)
+      tna = (topic_name.is_a? Array) ? topic_name : [topic_name]
+      ta = tna.collect do |tn|
+        t = create_topic(tn)
+        if block
+          block.call(t)
         end
-        topic_event(guard_block, &callback_logging(__method__, &event_block))
+        t
       end
+      ta[0]
     end
 
-    # Return a topic object represents pubsub topic
+    # Return the options used to initiate this
+    # communicator.
     #
-    def get_topic(topic_id)
-      OmfCommon::Topic.new(topic_id, self)
+    def options()
+      @opts
     end
+
+    private
+    def initialize(opts = {})
+      @opts = opts
+    end
+
   end
 end

data/lib/omf_common/comm/amqp/amqp_communicator.rb

@@ -0,0 +1,76 @@
+require 'amqp'
+require 'omf_common/comm/amqp/amqp_topic'
+#require 'omf_common/comm/monkey_patches'
+
+module OmfCommon
+  class Comm
+    class AMQP
+      class Communicator < OmfCommon::Comm
+        
+        # def initialize(opts = {})
+          # # ignore arguments
+        # end
+
+        # Initialize comms layer
+        #
+        def init(opts = {})
+          unless (@url = opts[:url])
+            raise "Missing 'url' option for AQMP layer"
+          end
+          @address_prefix = @url + '/'
+          ::AMQP.connect(@url) do |connection|
+            @channel  = ::AMQP::Channel.new(connection)
+            
+            if @on_connected_proc
+              @on_connected_proc.arity == 1 ? @on_connected_proc.call(self) : @on_connected_proc.call
+            end
+                      
+            OmfCommon.eventloop.on_stop do
+              connection.close
+            end
+          end
+        end
+  
+        # Shut down comms layer
+        def disconnect(opts = {})
+        end
+        
+        def on_connected(&block)
+          @on_connected_proc = block
+        end
+  
+        # Create a new pubsub topic with additional configuration
+        #
+        # @param [String] topic Pubsub topic name
+        def create_topic(topic, opts = {})
+          raise "Topic can't be nil or empty" if topic.nil? || topic.empty?
+          opts = opts.dup
+          opts[:channel] = @channel
+          if topic.start_with? 'amqp:'
+            # absolute address
+            unless topic.start_with? @address_prefix 
+              raise "Cannot subscribe to a topic from different domain (#{topic})"
+            end
+            opts[:address] = topic
+            topic = topic.split(@address_prefix).last
+          else
+            opts[:address] = @address_prefix + topic
+          end
+          OmfCommon::Comm::AMQP::Topic.create(topic, opts)
+        end
+  
+        # Delete a pubsub topic
+        #
+        # @param [String] topic Pubsub topic name
+        def delete_topic(topic, &block)
+          if t = OmfCommon::CommProvider::AMQP::Topic.find(topic)
+            t.release
+          else
+            warn "Attempt to delete unknown topic '#{topic}"
+          end        
+        end
+  
+      end
+    end
+  end
+end

data/lib/omf_common/comm/amqp/amqp_topic.rb

@@ -0,0 +1,91 @@
+
+
+module OmfCommon
+  class Comm
+    class AMQP
+      class Topic < OmfCommon::Comm::Topic
+
+        # def self.address_for(name)
+          # "#{name}@local"
+        # end
+        
+        def to_s
+          "AMQP::Topic<#{id}>"
+        end
+        
+        def address
+          @address
+        end
+        
+        # Call 'block' when topic is subscribed to underlying messaging
+        # infrastructure. 
+        #
+        def on_subscribed(&block)
+          return unless block
+          
+          call_now = false
+          @lock.synchronize do
+            if @subscribed
+              call_now = true
+            else
+              @on_subscrided_handlers << block
+            end
+          end
+          if call_now
+            after(0, &block)
+          end
+        end  
+        
+        
+        private
+        
+        def initialize(id, opts = {})
+          unless channel = opts.delete(:channel)
+            raise "Missing :channel option"
+          end
+          super
+          @address = opts[:address]
+          @exchange = channel.topic(id, :auto_delete => true)
+          @lock = Monitor.new
+          @subscribed = false
+          @on_subscrided_handlers = []
+          
+          # Subscribe as well
+          #puts "QQ0(#{id})"
+          channel.queue("", :exclusive => true) do |queue|
+            #puts "QQ1(#{id}): #{queue}"
+            queue.bind(@exchange)
+            queue.subscribe do |headers, payload|
+              #puts "===(#{id}) Incoming message '#{payload}'"
+              msg = Message.parse(payload)
+              #puts "---(#{id}) Parsed message '#{msg}'"
+              on_incoming_message(msg)
+            end
+            # Call all accumulated on_subscribed handlers
+            @lock.synchronize do
+              @subscribed = true
+              @on_subscrided_handlers.each do |block|
+                after(0, &block)
+              end
+              @on_subscrided_handlers = nil
+            end
+          end
+        end
+        
+        
+        def _send_message(msg, block = nil)
+          super
+          debug "(#{id}) Send message #{msg.inspect}"
+          content = msg.marshall
+          @exchange.publish(content)
+          # OmfCommon.eventloop.after(0) do
+            # on_incoming_message(msg)
+          # end
+        end
+        
+
+
+      end # class
+    end # module 
+  end # module
+end # module

data/lib/omf_common/comm/local/local_communicator.rb

@@ -0,0 +1,64 @@
+require 'omf_common/comm/local/local_topic'
+require 'omf_common/comm/monkey_patches'
+
+module OmfCommon
+  class Comm
+    class Local
+      class Communicator  < OmfCommon::Comm
+               
+        # def initialize(opts = {})
+          # # ignore arguments
+        # end
+
+        # Initialize comms layer
+        #
+        def init(opts = {})
+        end
+  
+        # Shut down comms layer
+        def disconnect(opts = {})
+        end
+  
+        # Create a new pubsub topic with additional configuration
+        #
+        # @param [String] topic Pubsub topic name
+        def create_topic(topic, &block)
+          t = OmfCommon::Comm::Local::Topic.create(topic)
+          if block
+            block.call(t)
+          end
+          t
+        end
+  
+        # Delete a pubsub topic
+        #
+        # @param [String] topic Pubsub topic name
+        def delete_topic(topic, &block)
+          if t = OmfCommon::CommProvider::Local::Topic.find(topic)
+            t.release
+          else
+            warn "Attempt to delete unknown topic '#{topic}"
+          end        
+        end
+  
+        def on_connected(&block)
+          return unless block
+          
+          OmfCommon.eventloop.after(0) do
+            block.arity == 1 ? block.call(self) : block.call
+          end
+        end
+  
+        # Publish to a pubsub topic
+        #
+        # @param [String] topic Pubsub topic name
+        # @param [String] message Any XML fragment to be sent as payload
+        # def publish(topic, message, &block)
+          # raise StandardError, "Invalid message" unless message.valid?
+#   
+        # end
+  
+      end
+    end
+  end
+end

data/lib/omf_common/comm/local/local_topic.rb

@@ -0,0 +1,42 @@
+
+
+module OmfCommon
+  class Comm
+    class Local
+      class Topic < OmfCommon::Comm::Topic
+
+        # def self.address_for(name)
+          # "#{name}@local"
+        # end
+        
+        def to_s
+          "Mock::Topic<#{id}>"
+        end
+        
+        def address
+          "local:/#{id}"
+        end
+        
+        def on_subscribed(&block)
+          return unless block
+          
+          OmfCommon.eventloop.after(0) do
+            block.arity == 1 ? block.call(self) : block.call
+          end
+        end  
+              
+        private
+        
+        def _send_message(msg, block = nil)
+          super
+          debug "(#{id}) Send message #{msg.inspect}"
+          OmfCommon.eventloop.after(0) do
+            on_incoming_message(msg)
+          end
+        end
+        
+
+      end # class
+    end # module 
+  end # module
+end # module