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

data/lib/omf_common/comm/topic.rb

@@ -0,0 +1,190 @@
+require 'monitor'
+require 'securerandom'
+
+module OmfCommon
+  class Comm
+    class Topic
+
+      @@name2inst = {}
+      @@lock = Monitor.new
+
+      def self.create(name, opts = {}, &block)
+        # Force string conversion as 'name' can be an ExperimentProperty
+        name = name.to_s.to_sym
+        @@lock.synchronize do
+          unless @@name2inst[name]
+            debug "New topic: #{name}"
+            #opts[:address] ||= address_for(name)
+            @@name2inst[name] = self.new(name, opts, &block)
+          else
+            debug "Existing topic: #{name}"
+            block.call(@@name2inst[name]) if block
+          end
+          @@name2inst[name]
+        end
+      end
+
+      def self.[](name)
+        @@name2inst[name]
+      end
+
+      attr_reader :id
+
+      # Request the creation of a new resource. Returns itself
+      #
+      def create(res_type, config_props = {}, core_props = {}, &block)
+        # new_res = nil
+        #res_name = res_name.to_sym
+        #config_props[:name] ||= res_name
+        config_props[:type] ||= res_type
+        debug "Create resource of type '#{res_type}'"
+        create_message_and_publish(:create, config_props, core_props, block)
+        self
+      end
+
+      def configure(props = {}, core_props = {}, &block)
+        create_message_and_publish(:configure, props, core_props, block)
+        self
+      end
+
+      def request(select = [], core_props = {}, &block)
+        # TODO: What are the parameters to the request method really?
+        create_message_and_publish(:request, select, core_props, block)
+        self
+      end
+
+      def inform(type, props = {}, core_props = {}, &block)
+        msg = OmfCommon::Message.create(:inform, props, core_props.merge(itype: type))
+        publish(msg, &block)
+        self
+      end
+
+      # def inform(type, props = {}, &block)
+        # msg = OmfCommon::Message.create(:inform, props)
+        # msg.itype = type
+        # publish(msg, &block)
+        # self
+      # end
+
+      def release(resource, core_props = {}, &block)
+        unless resource.is_a? self.class
+          raise "Expected '#{self.class}', but got '#{resource.class}'"
+        end
+        msg = OmfCommon::Message.create(:release, {}, core_props.merge(res_id: resource.id))
+        publish(msg, &block)
+        self
+      end
+
+
+      def create_message_and_publish(type, props = {}, core_props = {}, block = nil)
+        debug "(#{id}) create_message_and_publish '#{type}': #{props.inspect}"
+        msg = OmfCommon::Message.create(type, props, core_props)
+        publish(msg, &block)
+      end
+
+      def publish(msg, &block)
+        # TODO should it be _send_message(msg, &block) ?
+        #raise "Expected message but got '#{msg.class}" unless msg.is_a?(OmfCommon::Message)
+        _send_message(msg, block)
+      end
+
+      [:created,
+        :create_succeeded, :create_failed,
+        :inform_status, :inform_failed,
+        :released, :failed,
+        :message
+      ].each do |itype|
+        mname = "on_#{itype}"
+        define_method(mname) do |*args, &message_block|
+          debug "(#{id}) register handler for '#{mname}'"
+          @lock.synchronize do
+            (@handlers[itype] ||= []) << message_block
+          end
+          self
+        end
+      end
+
+      # Unsubscribe from the underlying comms layer
+      #
+      def unsubscribe()
+
+      end
+
+      def on_subscribed(&block)
+        raise "Not implemented"
+      end
+
+      # For detecting message publishing error, means if callback indeed yield a Topic object, there is no publishing error, thus always false
+      def error?
+        false
+      end
+
+      def address
+        raise "Not implemented"
+      end
+
+      def after(delay_sec, &block)
+        return unless block
+        OmfCommon.eventloop.after(delay_sec) do
+          block.arity == 1 ? block.call(self) : block.call
+        end
+      end
+
+      private
+
+      def initialize(id, opts = {})
+        @id = id
+        #@address = opts[:address]
+        @handlers = {}
+        @lock = Monitor.new
+        @context2cbk = {}
+      end
+
+
+      def _send_message(msg, block = nil)
+        if (block)
+          # register callback for responses to 'mid'
+          @context2cbk[msg.mid.to_s] = {block: block, created_at: Time.now}
+        end
+      end
+
+      def on_incoming_message(msg)
+        type = msg.operation
+        debug "(#{id}) Deliver message '#{type}': #{msg.inspect}"
+        htypes = [type, :message]
+        if type == :inform
+          if it = msg.itype.to_s.downcase
+            #puts "TTT> #{it}"
+            case it
+            when "creation_ok"
+              htypes << :create_succeeded
+            when 'status'
+              htypes << :inform_status
+            else
+              htypes << it.to_sym
+            end
+          end
+        end
+
+        debug "(#{id}) Message type '#{htypes.inspect}' (#{msg.class}:#{msg.cid})"
+        hs = htypes.map do |ht| @handlers[ht] end.compact.flatten
+        debug "(#{id}) Distributing message to '#{hs.inspect}'"
+        hs.each do |block|
+          block.call msg
+        end
+        if cbk = @context2cbk[msg.cid.to_s]
+          debug "(#{id}) Distributing message to '#{cbk.inspect}'"
+          cbk[:last_used] = Time.now
+          cbk[:block].call(msg)
+        # else
+          # if msg.cid
+            # puts "====NOOOO for #{msg.cid} - #{@context2cbk.keys.inspect}"
+          # end
+        end
+
+      end
+
+
+    end
+  end
+end

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

@@ -1,10 +1,18 @@
 require 'blather/client/dsl'
 
+require 'omf_common/comm/xmpp/xmpp_mp'
+require 'omf_common/comm/xmpp/topic'
+require 'uri'
+require 'socket'
+
 module OmfCommon
-  module DSL
-    module Xmpp
+class Comm
+  class XMPP
+    class Communicator < OmfCommon::Comm
       include Blather::DSL
 
+      attr_accessor :published_messages, :normal_shutdown_mode, :retry_counter
+
       HOST_PREFIX = 'pubsub'
 
       PUBSUB_CONFIGURE = Blather::Stanza::X.new({
@@ -17,9 +25,63 @@ module OmfCommon
           { :var => "pubsub#publish_model", :value => "open" }]
       })
 
+      # Capture system :INT & :TERM signal
+      def on_interrupted(&block)
+        if block
+          trap(:INT) { block.call(self) }
+          trap(:TERM) { block.call(self) }
+        end
+      end
+
+      def on_connected(&block)
+        when_ready do
+          block.call(self)
+        end
+      end
+
+      # Set up XMPP options and start the Eventmachine, connect to XMPP server
+      #
+      def init(opts = {})
+        @pubsub_host = opts[:pubsub_domain]
+        if opts[:url]
+          url = URI(opts[:url])
+          username, password, server = url.user, url.password, url.host
+        else
+          username, password, server = opts[:username], opts[:password], opts[:server]
+        end
+
+        random_name = "#{Socket.gethostname}-#{Process.pid}"
+        username ||= random_name
+        password ||= random_name
+
+        raise ArgumentError, "Username cannot be nil when connect to XMPP" if username.nil?
+        raise ArgumentError, "Password cannot be nil when connect to XMPP" if password.nil?
+        raise ArgumentError, "Server cannot be nil when connect to XMPP" if server.nil?
+
+        @retry_counter = 0
+        @normal_shutdown_mode = false
+
+        connect(username, password, server)
+
+        disconnected do
+          unless normal_shutdown_mode
+            unless retry_counter > 0
+              @retry_counter += 1
+              client.connect
+            else
+              error "Authentication failed."
+              OmfCommon.eventloop.stop
+            end
+          else
+            shutdown
+          end
+        end
+      end
+
       # Set up XMPP options and start the Eventmachine, connect to XMPP server
       #
       def connect(username, password, server)
+        info "Connecting to '#{server}' ..."
         jid = "#{username}@#{server}"
         client.setup(jid, password)
         client.run
@@ -28,38 +90,18 @@ module OmfCommon
 
       # Shut down XMPP connection
       def disconnect(opts = {})
-        if opts[:delete_affiliations]
-          affiliations do |a|
-            # owner means topics created, owned
-            owner_topics = a[:owner] ? a[:owner].size : 0
-            # none means... topics subscribed to
-            none_topics = a[:none] ? a[:none].size : 0
-
-            if none_topics > 0
-              info "Unsubscribing #{none_topics} pubsub topic(s)"
-              unsubscribe
-            end
-
-            if owner_topics > 0
-              info "Deleting #{owner_topics} pubsub topic(s) in 2 seconds"
-              EM.add_timer(2) do
-                a[:owner].each { |topic| delete_topic(topic) }
-              end
-            end
-
-            shutdown if none_topics == 0 && owner_topics == 0
-          end
-        else
-          shutdown
-        end
+        # NOTE Do not clean up
+        info "Disconnecting ..."
+        @normal_shutdown_mode = true
+        shutdown
         OmfCommon::DSL::Xmpp::MPConnection.inject(Time.now.to_f, jid, 'disconnect') if OmfCommon::Measure.enabled?
       end
 
       # Create a new pubsub topic with additional configuration
       #
       # @param [String] topic Pubsub topic name
-      def create_topic(topic, &block)
-        pubsub.create(topic, default_host, PUBSUB_CONFIGURE, &callback_logging(__method__, topic, &block))
+      def create_topic(topic, opts = {})
+        OmfCommon::Comm::XMPP::Topic.create(topic)
       end
 
       # Delete a pubsub topic
@@ -75,22 +117,19 @@ module OmfCommon
       # @param [Hash] opts
       # @option opts [Boolean] :create_if_non_existent create the topic if non-existent, use this option with caution
       def subscribe(topic, opts = {}, &block)
-        if opts[:create_if_non_existent]
-          affiliations do |a|
-            if a[:owner] && a[:owner].include?(topic)
-              pubsub.subscribe(topic, nil, default_host, &callback_logging(__method__, topic, &block))
-            else
-              create_topic(topic) do
-                pubsub.subscribe(topic, nil, default_host, &callback_logging(__method__, topic, &block))
-              end
-            end
-          end
-        else
-          pubsub.subscribe(topic, nil, default_host, &callback_logging(__method__, topic, &block))
-        end
+        topic = topic.first if topic.is_a? Array
+        OmfCommon::Comm::XMPP::Topic.create(topic, &block)
         MPSubscription.inject(Time.now.to_f, jid, 'join', topic) if OmfCommon::Measure.enabled?
       end
 
+      def _subscribe(topic, &block)
+        pubsub.subscribe(topic, nil, default_host, &callback_logging(__method__, topic, &block))
+      end
+
+      def _create(topic, &block)
+        pubsub.create(topic, default_host, PUBSUB_CONFIGURE, &callback_logging(__method__, topic, &block))
+      end
+
       # Un-subscribe all existing subscriptions from all pubsub topics.
       def unsubscribe
         pubsub.subscriptions(default_host) do |m|
@@ -108,10 +147,12 @@ module OmfCommon
       # Publish to a pubsub topic
       #
       # @param [String] topic Pubsub topic name
-      # @param [String] message Any XML fragment to be sent as payload
+      # @param [OmfCommon::Message] message Any XML fragment to be sent as payload
       def publish(topic, message, &block)
         raise StandardError, "Invalid message" unless message.valid?
 
+        message = message.xml unless message.kind_of? String
+
         new_block = proc do |stanza|
           published_messages << OpenSSL::Digest::SHA1.new(message.to_s)
           block.call(stanza) if block
@@ -121,13 +162,6 @@ module OmfCommon
         MPPublished.inject(Time.now.to_f, jid, topic, message.to_s.gsub("\n",'')) if OmfCommon::Measure.enabled?
       end
 
-      # Event machine related method delegation
-      %w(add_timer add_periodic_timer).each do |m_name|
-        define_method(m_name) do |*args, &block|
-          EM.send(m_name, *args, &block)
-        end
-      end
-
       # Event callback for pubsub topic event(item published)
       #
       def topic_event(additional_guard = nil, &block)
@@ -148,16 +182,21 @@ module OmfCommon
 
       private
 
+      def initialize(opts = {})
+        self.published_messages = []
+        super
+      end
+
       # Provide a new block wrap to automatically log errors
       def callback_logging(*args, &block)
-        m = args.empty? ? "OPERATION" : args.map {|v| v.to_s.upcase }.join(" ")
+        m = args.empty? ? "OPERATION" : args.join(" >> ")
         proc do |stanza|
           if stanza.respond_to?(:error?) && stanza.error?
             e_stanza = Blather::StanzaError.import(stanza)
             if [:unexpected_request].include? e_stanza.name
               logger.debug e_stanza
-            elsif e_stanza.name == :conflict 
-              logger.debug e_stanza
+            elsif e_stanza.name == :conflict
+              #logger.debug e_stanza
             else
               logger.warn "#{e_stanza} Original: #{e_stanza.original}"
             end
@@ -168,8 +207,9 @@ module OmfCommon
       end
 
       def default_host
-        "#{HOST_PREFIX}.#{client.jid.domain}"
+        @pubsub_host || "#{HOST_PREFIX}.#{jid.domain}"
       end
     end
   end
 end
+end

data/lib/omf_common/comm/xmpp/topic.rb

@@ -0,0 +1,147 @@
+module OmfCommon
+class Comm
+class XMPP
+  class Topic < OmfCommon::Comm::Topic
+    %w(creation.ok creation.failed status released error warn).each do |itype|
+      define_method("on_#{itype.gsub(/\./, '_')}") do |*args, &message_block|
+        mid = args[0].mid if args[0]
+
+        raise ArgumentError, 'Missing callback' if message_block.nil?
+
+        event_block = proc do |event|
+          message_block.call(OmfCommon::Message.parse(event.items.first.payload))
+        end
+
+        guard_block = proc do |event|
+          (event.items?) && (!event.delayed?) &&
+            event.items.first.payload &&
+            (omf_message = OmfCommon::Message.parse(event.items.first.payload)) &&
+            event.node == id.to_s &&
+            omf_message.operation == :inform &&
+            omf_message.read_content(:itype) == itype.upcase &&
+            (mid ? (omf_message.cid == mid) : true)
+        end
+
+        OmfCommon.comm.topic_event(guard_block, &event_block)
+      end
+    end
+
+    def on_message(message_guard_proc = nil, ref_id = 0, &message_block)
+      @lock.synchronize do
+        @on_message_cbks[ref_id] ||= []
+        @on_message_cbks[ref_id] << message_block
+      end
+
+      event_block = proc do |event|
+        @on_message_cbks.each do |id, cbks|
+          cbks.each do |cbk|
+            cbk.call(OmfCommon::Message.parse(event.items.first.payload))
+          end
+        end
+      end
+
+      guard_block = proc do |event|
+        (event.items?) && (!event.delayed?) &&
+          event.items.first.payload &&
+          (omf_message = OmfCommon::Message.parse(event.items.first.payload)) &&
+          event.node == id.to_s &&
+          (valid_guard?(message_guard_proc) ? message_guard_proc.call(omf_message) : true)
+      end
+      OmfCommon.comm.topic_event(guard_block, &event_block)
+    end
+
+    def delete_on_message_cbk_by_id(id)
+      @lock.synchronize do
+        @on_message_cbks[id] && @on_message_cbks.reject! { |k| k == id.to_s }
+      end
+    end
+
+    def inform(type, props = {}, core_props = {}, &block)
+      msg = OmfCommon::Message.create(:inform, props, core_props.merge(itype: type))
+      publish(msg, &block)
+      self
+    end
+
+    def publish(msg, &block)
+      _send_message(msg, &block)
+    end
+
+    def address
+      "xmpp://#{id.to_s}@#{OmfCommon.comm.jid.domain}"
+    end
+
+    def on_subscribed(&block)
+      return unless block
+
+      @lock.synchronize do
+        @on_subscrided_handlers << block
+      end
+    end
+
+    private
+
+    def initialize(id, opts = {}, &block)
+      @on_message_cbks = Hashie::Mash.new
+
+      id = $1 if id =~ /^xmpp:\/\/(.+)@.+$/
+
+      super
+
+      @on_subscrided_handlers = []
+
+      topic_block = proc do |stanza|
+        if stanza.error?
+          block.call(stanza) if block
+        else
+          block.call(self) if block
+
+          @lock.synchronize do
+            @on_subscrided_handlers.each do |handler|
+              handler.call
+            end
+          end
+        end
+      end
+
+      OmfCommon.comm._create(id.to_s) do |stanza|
+        if stanza.error?
+          e_stanza = Blather::StanzaError.import(stanza)
+          if e_stanza.name == :conflict
+            # Topic exists, just subscribe to it.
+            OmfCommon.comm._subscribe(id.to_s, &topic_block)
+          else
+            block.call(stanza) if block
+          end
+        else
+          OmfCommon.comm._subscribe(id.to_s, &topic_block)
+        end
+      end
+    end
+
+    def _send_message(msg, &block)
+      # while sending a message, need to setup handler for replying messages
+      OmfCommon.comm.publish(self.id, msg) do |stanza|
+        if !stanza.error? && !block.nil?
+          on_error(msg, &block)
+          on_warn(msg, &block)
+          case msg.operation
+          when :create
+            on_creation_ok(msg, &block)
+            on_creation_failed(msg, &block)
+          when :configure, :request
+            on_status(msg, &block)
+          when :release
+            on_released(msg, &block)
+          end
+        end
+      end
+    end
+
+    def valid_guard?(guard_proc)
+      guard_proc && guard_proc.class == Proc
+    end
+
+  end
+end
+end
+end