omf_common 6.0.0 → 6.0.2.pre.1

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

@@ -5,10 +5,6 @@ module OmfCommon
     class AMQP
       class Topic < OmfCommon::Comm::Topic
 
-        # def self.address_for(name)
-          # "#{name}@local"
-        # end
-        
         def to_s
           "AMQP::Topic<#{id}>"
         end
@@ -28,7 +24,7 @@ module OmfCommon
             if @subscribed
               call_now = true
             else
-              @on_subscrided_handlers << block
+              @on_subscribed_handlers << block
             end
           end
           if call_now
@@ -48,7 +44,7 @@ module OmfCommon
           @exchange = channel.topic(id, :auto_delete => true)
           @lock = Monitor.new
           @subscribed = false
-          @on_subscrided_handlers = []
+          @on_subscribed_handlers = []
           
           # Subscribe as well
           #puts "QQ0(#{id})"
@@ -56,18 +52,21 @@ module OmfCommon
             #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)
+              #puts "===(#{id}) Incoming message '#{headers.content_type}'"
+              debug "Received message on #{@address}"
+              Message.parse(payload, headers.content_type) do |msg|
+                #puts "---(#{id}) Parsed message '#{msg}'"
+                on_incoming_message(msg)
+              end
             end
+            debug "Subscribed to '#@id'"
             # Call all accumulated on_subscribed handlers
             @lock.synchronize do
               @subscribed = true
-              @on_subscrided_handlers.each do |block|
+              @on_subscribed_handlers.each do |block|
                 after(0, &block)
               end
-              @on_subscrided_handlers = nil
+              @on_subscribed_handlers = nil
             end
           end
         end
@@ -75,16 +74,10 @@ module OmfCommon
         
         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
+          content_type, content = msg.marshall(self)
+          debug "(#{id}) Send message (#{content_type}) #{msg.inspect}"
+          @exchange.publish(content, content_type: content_type, message_id: msg.mid)
         end
-        
-
-
       end # class
     end # module 
   end # module

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

@@ -1,11 +1,10 @@
 require 'omf_common/comm/local/local_topic'
-require 'omf_common/comm/monkey_patches'
+require 'securerandom'
 
 module OmfCommon
   class Comm
     class Local
       class Communicator  < OmfCommon::Comm
-               
         # def initialize(opts = {})
           # # ignore arguments
         # end
@@ -13,6 +12,8 @@ module OmfCommon
         # Initialize comms layer
         #
         def init(opts = {})
+          @distributed_files = {}
+					super
         end
   
         # Shut down comms layer
@@ -49,6 +50,34 @@ module OmfCommon
           end
         end
   
+        def broadcast_file(file_path, topic_url = nil, opts = {}, &block)
+          topic_url ||= SecureRandom.uuid
+          @distributed_files[topic_url] = file_path
+          "bdcst:local:#{topic_url}"
+        end
+  
+        def receive_file(topic_url, file_path = nil, opts = {}, &block)
+          if topic_url.start_with? 'local:'
+            topic_url = topic_url[6 .. -1]
+          end
+          file_path ||= File.join(Dir.tmpdir, Dir::Tmpname.make_tmpname('bdcast', ''))
+          OmfCommon.eventloop.after(0) do
+            #puts ">>>>>> #{topic_url}::#{@distributed_files.keys}"
+            unless original = @distributed_files[topic_url]
+              raise "File '#{topic_url}' hasn't started broadcasting"
+            end
+            mime_type = `file -b --mime-type #{original}`
+            `cp #{original} #{file_path}`
+            unless $?.success?
+              error "Couldn't copy '#{original}' to '#{file_path}'"
+            end
+            if block
+              block.call({action: :done, mime_type: mime_type.strip, path: file_path, size: -1, received: -1})
+            end
+          end
+          file_path
+        end
+  
         # Publish to a pubsub topic
         #
         # @param [String] topic Pubsub topic name

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

@@ -4,7 +4,14 @@ module OmfCommon
   class Comm
     class Local
       class Topic < OmfCommon::Comm::Topic
-
+        @@marshall_messages = true
+        
+        # If set to 'true' marshall and immediately unmarshall before handing it on
+        # messages
+        def self.marshall_messages=(flag)
+          @@marshall_messages = (flag == true)
+        end
+        
         # def self.address_for(name)
           # "#{name}@local"
         # end
@@ -30,8 +37,17 @@ module OmfCommon
         def _send_message(msg, block = nil)
           super
           debug "(#{id}) Send message #{msg.inspect}"
-          OmfCommon.eventloop.after(0) do
-            on_incoming_message(msg)
+          if @@marshall_messages
+            content_type, payload = msg.marshall(self)
+            Message.parse(payload, content_type) do
+              OmfCommon.eventloop.after(0) do
+                on_incoming_message(msg)
+              end   
+            end
+          else
+            OmfCommon.eventloop.after(0) do
+              on_incoming_message(msg)
+            end
           end
         end
         

data/lib/omf_common/comm/topic.rb

@@ -33,9 +33,6 @@ module OmfCommon
       # 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)
@@ -54,56 +51,61 @@ module OmfCommon
       end
 
       def inform(type, props = {}, core_props = {}, &block)
+        core_props[:src] ||= OmfCommon.comm.local_address
         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}'"
+          raise ArgumentError, "Expected '#{self.class}', but got '#{resource.class}'"
         end
+        core_props[:src] ||= OmfCommon.comm.local_address
         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}"
+        core_props[:src] ||= OmfCommon.comm.local_address
         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)
+        raise "Expected message but got '#{msg.class}" unless msg.is_a?(OmfCommon::Message)
         _send_message(msg, block)
       end
 
+      # TODO we should fix this long list related to INFORM messages
+      # according to FRCP, inform types are (underscore form):
+      # :creation_ok, :creation_failed, :status, :error, :warn, :released
+      #
+      # and we shall add :message for ALL types of messages.
       [:created,
         :create_succeeded, :create_failed,
         :inform_status, :inform_failed,
         :released, :failed,
-        :message
+        :creation_ok, :creation_failed, :status, :error, :warn
       ].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
+          warn_deprecation(mname, :on_message, :on_inform)
+
+          add_message_handler(itype, &message_block)
         end
       end
 
+      def on_message(*args, &message_block)
+        add_message_handler(:message, &message_block)
+      end
+
+      def on_inform(*args, &message_block)
+        add_message_handler(:inform, &message_block)
+      end
+
       # Unsubscribe from the underlying comms layer
       #
       def unsubscribe()
@@ -111,7 +113,7 @@ module OmfCommon
       end
 
       def on_subscribed(&block)
-        raise "Not implemented"
+        raise NotImplementedError
       end
 
       # For detecting message publishing error, means if callback indeed yield a Topic object, there is no publishing error, thus always false
@@ -120,7 +122,7 @@ module OmfCommon
       end
 
       def address
-        raise "Not implemented"
+        raise NotImplementedError
       end
 
       def after(delay_sec, &block)
@@ -140,34 +142,43 @@ module OmfCommon
         @context2cbk = {}
       end
 
-
+      # _send_message will also register callbacks for reply messages by default
+      #
       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}
+          debug "(#{id}) register callback for responses to 'mid: #{msg.mid}'"
+          @lock.synchronize do
+            @context2cbk[msg.mid.to_s] = { block: block, created_at: Time.now }
+          end
         end
       end
 
+      # Process a message received from this topic.
+      #
+      # @param [OmfCommon::Message] msg Message received
+      # @param [Hash] auth_info Authentication information
+      # @option auth_info [Symbol] :signer Id
       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}"
+          # TODO keep converting itype is painful, need to solve this.
+          if (it = msg.itype(:ruby)) # format itype as lower case string
             case it
             when "creation_ok"
               htypes << :create_succeeded
             when 'status'
               htypes << :inform_status
-            else
-              htypes << it.to_sym
             end
+
+            htypes << it.to_sym
           end
         end
 
         debug "(#{id}) Message type '#{htypes.inspect}' (#{msg.class}:#{msg.cid})"
-        hs = htypes.map do |ht| @handlers[ht] end.compact.flatten
+        hs = htypes.map { |ht| @handlers[ht] }.compact.flatten
         debug "(#{id}) Distributing message to '#{hs.inspect}'"
         hs.each do |block|
           block.call msg
@@ -176,14 +187,17 @@ module OmfCommon
           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
 
+      def add_message_handler(handler_name, &message_block)
+        raise ArgumentError, 'Missing message callback' if message_block.nil?
+        debug "(#{id}) register handler for '#{handler_name}'"
+        @lock.synchronize do
+          (@handlers[handler_name] ||= []) << message_block
+        end
+        self
+      end
 
     end
   end

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

@@ -25,18 +25,17 @@ class Comm
           { :var => "pubsub#publish_model", :value => "open" }]
       })
 
+      def conn_info
+        { proto: :xmpp, user: jid.node, domain: jid.domain }
+      end
+
       # Capture system :INT & :TERM signal
       def on_interrupted(&block)
-        if block
-          trap(:INT) { block.call(self) }
-          trap(:TERM) { block.call(self) }
-        end
+        @cbks[:interpreted] << block
       end
 
       def on_connected(&block)
-        when_ready do
-          block.call(self)
-        end
+        @cbks[:connected] << block
       end
 
       # Set up XMPP options and start the Eventmachine, connect to XMPP server
@@ -63,6 +62,10 @@ class Comm
 
         connect(username, password, server)
 
+        when_ready do
+          @cbks[:connected].each { |cbk| cbk.call(self) }
+        end
+
         disconnected do
           unless normal_shutdown_mode
             unless retry_counter > 0
@@ -76,6 +79,11 @@ class Comm
             shutdown
           end
         end
+
+        trap(:INT) { @cbks[:interpreted].empty? ? disconnect : @cbks[:interpreted].each { |cbk| cbk.call(self) } }
+        trap(:TERM) { @cbks[:interpreted].empty? ? disconnect : @cbks[:interpreted].each { |cbk| cbk.call(self) } }
+
+        super
       end
 
       # Set up XMPP options and start the Eventmachine, connect to XMPP server
@@ -151,7 +159,7 @@ class Comm
       def publish(topic, message, &block)
         raise StandardError, "Invalid message" unless message.valid?
 
-        message = message.xml unless message.kind_of? String
+        message = message.marshall[1] unless message.kind_of? String
 
         new_block = proc do |stanza|
           published_messages << OpenSSL::Digest::SHA1.new(message.to_s)
@@ -166,8 +174,8 @@ class Comm
       #
       def topic_event(additional_guard = nil, &block)
         guard_block = proc do |event|
-          passed = (event.items?) && (!event.delayed?) && event.items.first.payload &&
-            !published_messages.include?(OpenSSL::Digest::SHA1.new(event.items.first.payload))
+          passed = !event.delayed? && event.items? && !event.items.first.payload.nil? #&&
+            #!published_messages.include?(OpenSSL::Digest::SHA1.new(event.items.first.payload))
 
           MPReceived.inject(Time.now.to_f, jid, event.node, event.items.first.payload.to_s.gsub("\n",'')) if OmfCommon::Measure.enabled? && passed
 
@@ -184,6 +192,7 @@ class Comm
 
       def initialize(opts = {})
         self.published_messages = []
+        @cbks = {connected: [], interpreted: []}
         super
       end
 

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

@@ -2,69 +2,11 @@ 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 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 address
       "xmpp://#{id.to_s}@#{OmfCommon.comm.jid.domain}"
@@ -81,8 +23,6 @@ class XMPP
     private
 
     def initialize(id, opts = {}, &block)
-      @on_message_cbks = Hashie::Mash.new
-
       id = $1 if id =~ /^xmpp:\/\/(.+)@.+$/
 
       super
@@ -103,6 +43,8 @@ class XMPP
         end
       end
 
+      # Create xmpp pubsub topic, then subscribe to it
+      #
       OmfCommon.comm._create(id.to_s) do |stanza|
         if stanza.error?
           e_stanza = Blather::StanzaError.import(stanza)
@@ -116,31 +58,30 @@ class XMPP
           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
+      event_block = proc do |event|
+        OmfCommon::Message.parse(event.items.first.payload) do |parsed_msg|
+          on_incoming_message(parsed_msg)
         end
       end
+
+      OmfCommon.comm.topic_event(default_guard, &event_block)
+    end
+
+    def _send_message(msg, block)
+      super
+      OmfCommon.comm.publish(self.id, msg)
     end
 
     def valid_guard?(guard_proc)
       guard_proc && guard_proc.class == Proc
     end
 
+    def default_guard
+      proc do |event|
+        event.node == self.id.to_s
+      end
+    end
   end
 end
 end