message_channel 1.0.0

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "message_channel"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/message_channel.rb

@@ -0,0 +1,18 @@
+require  "message_channel/version"
+require  "message_channel/base"
+
+module MessageChannel
+
+  class Error < StandardError; end
+
+  class  <<  self
+    include MessageChannel::Base
+  end
+
+  autoload  :Observer, "message_channel/observer"
+  autoload  :Druby, "message_channel/druby"
+  autoload  :Mqtt, "message_channel/mqtt"
+  autoload  :Redis, "message_channel/redis"
+  autoload  :Mongodb, "message_channel/mongodb"
+end
+

data/lib/message_channel/base.rb

@@ -0,0 +1,54 @@
+module MessageChannel
+  class Error < StandardError; end
+
+  module Base
+
+    # uri:
+    #  "observer"
+    #  "druby://127.0.0.1:8787"
+    #  "mqtt://127.0.0.1:1883"
+    #  "redis://127.0.0.1:6379/0"
+    #  "mongodb://127.0.0.1:27017/test?size=4000&name=_event_queue"
+
+    def new( uri = nil, type: nil, host: nil, port: nil, db: nil, size: nil, name: nil )
+      if  uri
+        uris  =  URI.parse( uri )
+        if  uris.scheme.nil?  &&  uris.host.nil?  &&  uris.port.nil?  &&  uris.path
+          type  =  uris.path
+          params  =  []
+        else
+          type  =  uris.scheme  ||  type
+          host  =  uris.host  ||  host
+          port  =  uris.port  ||  port
+          params  =  uris.path.gsub(/^\//, "").split('/')
+          query  =  Hash[ URI::decode_www_form(uris.query) ]  rescue  {}
+          size  =  query[:size]  ||  size
+          name  =  query[:name]  ||  name
+        end
+      else
+        parans  =  []
+      end
+
+      options  =  { host: host, port: port }
+
+      case  type
+      when  "observer", NilClass
+        MessageChannel::Observer.new( **options )
+      when  "druby"
+        MessageChannel::Druby.new( **options )
+      when  "mqtt"
+        MessageChannel::Mqtt.new( **options )
+      when  "redis"
+        options[:db]  =  params.shift  ||  db
+        MessageChannel::Redis.new( **options )
+      when  "mongodb"
+        options[:db]  =  params.shift  ||  db
+        options[:size]  =  size
+        options[:name]  =  name
+        MessageChannel::Mongodb.new( **options )
+      end
+    end
+
+  end
+end
+

data/lib/message_channel/druby.rb

@@ -0,0 +1,182 @@
+require  "drb/drb"
+require  "json"
+
+module MessageChannel
+
+  class Druby
+
+    class Broker
+      def initialize
+        @mutex  =  Mutex.new
+        @patterns  =  {}
+      end
+
+      def subscribe( pattern )
+        queue  =  Queue.new
+        queue_id  =  queue.object_id
+        @mutex.synchronize do
+          @patterns[queue_id]  =  [pattern, queue]
+        end
+        queue_id
+      end
+
+      def unsubscribe( queue_id )
+        @mutex.synchronize do
+          @patterns.delete( queue_id )    rescue  nil
+        end
+      rescue
+        nil
+      end
+
+      def wait( queue_id )
+        @patterns[queue_id].last.pop
+      end
+      
+      def fetch( pattern )
+        queue  =  Queue.new
+        queue_id  =  queue.object_id
+        @mutex.synchronize do
+          @patterns[queue_id]  =  [pattern, queue]
+        end
+        topic, items  =  * queue.pop
+      rescue
+        nil
+      ensure
+        @mutex.synchronize do
+          @patterns.delete( queue_id )    rescue  nil
+        end
+      end
+
+      def publish( topic, message )
+        @mutex.synchronize do
+          @patterns.each do |queue_id, items|
+            pattern, queue  =  *items
+            if File.fnmatch( pattern, topic, File::FNM_PATHNAME )
+              queue.push( [topic, message] )
+            end
+          end
+        end
+      end
+    end
+
+    class Agent
+      def initialize( host: @@host, port: @@port )
+        @@host  =  host
+        @@port  =  port
+        @uri  =  "druby://#{host}:#{port}"
+ 
+        if  !defined?( @@Broker )  ||  @@Broker.nil?
+          @@Broker  =  Broker.new
+          DRb.start_service( @uri, @@Broker )    rescue nil
+        end
+ 
+        @drb  =  DRbObject.new_with_uri( @uri )
+        @queue_ids  =  {}
+      end
+
+      def listen_once( pattern )
+        topic, message  =  * @drb.fetch( pattern )
+      end
+
+      def listen_each( pattern, &block )
+        queue_id  =  @drb.subscribe( pattern )
+        @queue_ids[pattern]  =  queue_id
+        while  true
+          topic, message  =  * @drb.wait( queue_id )
+          break    if  topic.nil?
+          block.call( topic, message )
+        end
+      rescue => error
+        nil
+      ensure
+        @drb.unsubscribe( queue_id )
+        @queue_ids.delete( pattern )    rescue  nil
+      end
+
+      def unlisten( pattern )
+        if  queue_id  =  @queue_ids[pattern]
+          @drb.unsubscribe( queue_id )
+          @queue_ids.delete( pattern )    rescue  nil
+        end
+      end
+
+      def notify( topic, message )
+        @drb.publish( topic, message )
+      end
+    end
+
+    attr_reader  :host, :port
+
+    def initialize( host: nil, port: nil )
+      @host  =  host  || "127.0.0.1"
+      @port  =  ( port  ||  8787 ).to_i
+      @agent  =  Agent.new( host: @host, port: @port )
+      @threads  =  {}
+    end
+
+    def listen_once( *patterns )
+      queue  =  Queue.new
+      threads  =  {}
+      patterns.each do |pattern|
+        threads[pattern]  =  Thread.start(pattern) do |pattern|
+          agent  =  Agent.new
+          begin
+            topic, message  =  * agent.listen_once( pattern )
+            items  =  JSON.parse( message, symbolize_names: true )
+            queue.push( [topic, items] )
+          rescue => error
+            nil
+          end
+        end
+      end
+
+      topic, items  =  queue.pop
+      patterns.each do |pattern|
+        threads[pattern].kill    rescue  nil
+        threads.delete( pattern )    rescue  nil
+      end
+      [topic, items]
+    rescue
+      nil
+    end
+
+    def listen_each( *patterns, &block )
+      patterns.each do |pattern|
+        @threads[pattern]  =  Thread.start(pattern) do |pattern|
+          begin
+            @agent.listen_each( pattern ) do |topic, message| 
+              items  =  JSON.parse( message, symbolize_names: true )
+              block.call( topic, items )
+            end
+          rescue => error
+            nil
+          end
+        end
+      end
+    end
+
+    def listen( *patterns, &block )
+      if block.nil?
+        listen_once( *patterns )
+      else
+        listen_each( *patterns ) do |topic, items|
+          block.call( topic, items )
+        end
+      end
+    end
+
+    def unlisten( **patterns )
+      patterns.each do |pattern|
+        @agent.unlisten( pattern )
+        @threads.delete( pattern )
+      end
+    end
+
+    def notify( topic, **items )
+      @agent.notify( topic, items.to_json )
+    end
+
+  end
+
+end
+

data/lib/message_channel/mongodb.rb

@@ -0,0 +1,131 @@
+require  "mongo"
+require  "json"
+
+::Mongo::Logger.logger.level  =  Logger::ERROR
+
+module MessageChannel
+  class Mongodb
+    SIZE  =  8000
+    NAME  =  "_event_queue"
+
+    def initialize( host: nil, port: nil, db: nil, size: nil, name: nil )
+      @host  =  host  ||  "127.0.0.1"
+      @port  =  ( port  ||  27017 ).to_i
+      @db    =  db  ||  "test"
+      @size  =  ( size  ||  SIZE ).to_i
+      @name  =  name  ||  NAME
+
+      @url   =  "mongodb://#{ @host }:#{ @port }/#{ @db }"
+      @client  =  ::Mongo::Client.new( @url )
+
+      @threads  =  {}
+      @mutex  =  Mutex.new
+
+      @event_queue  =  get_event_queue
+    end
+
+    def get_event_queue
+      event_queue  =  @mutex.synchronize do
+        if  @client.database.collection_names.include?( @name )
+          event_queue  =  @client[ @name ]
+        else
+          event_queue  =  @client[ @name, capped: true, size: @size ]
+          event_queue.create
+          now  =  Time.now
+          doc  =  {
+            topic: "reset",
+            at: now.strftime("%Y%m%d.%H%M%S.%6L"),
+          }
+          event_queue.insert_one( doc )
+          event_queue
+        end
+      end
+    end
+
+    def get_event_tail( event_queue )
+      filter  =  {}
+      if  enum  =  event_queue.find( {}, { sort: { "$natural" => -1 } } ).to_enum
+        if  doc  =  enum.next    rescue  nil
+          filter  =  { "_id"=>{ "$gt"=>doc["_id"] } }
+        end
+      end
+      event_tail  =  event_queue.find( filter, { cursor_type: :tailable_await } ).to_enum
+    end
+
+    def listen_once( *patterns )
+      queue  =  Queue.new
+      threads  =  {}
+      patterns.each do |pattern|
+        threads[pattern]  =  ::Thread.start(pattern) do |pattern|
+          event_queue  =  get_event_queue
+          event_tail  =  get_event_tail( event_queue )
+          begin
+            while  doc  =  event_tail.next
+              items  =  JSON.parse( doc.to_json, symbolize_names: true )
+              topic  =  items[:topic]
+              if File.fnmatch( pattern, topic, File::FNM_PATHNAME )
+                items.delete( :_id )
+                items.delete( :topic )
+                queue.push  [topic, items]
+              end
+            end
+          ensure
+          end
+        end
+      end
+
+      topic, items  =  queue.pop
+      patterns.each do |pattern|
+        threads[pattern].kill    rescue  nil
+        threads.delete( pattern )    rescue  nil
+      end
+      [topic, items]
+    end
+
+    def listen_each( *patterns, &block )
+      patterns.each do |pattern|
+        @threads[pattern]  =  ::Thread.start(pattern) do |pattern|
+          begin
+            event_queue  =  get_event_queue
+            event_tail  =  get_event_tail( event_queue )
+            while  doc  =  event_tail.next
+              items  =  JSON.parse( doc.to_json, symbolize_names: true )
+              topic  =  items[:topic]
+              if File.fnmatch( pattern, topic, File::FNM_PATHNAME )
+                items.delete( :_id )
+                items.delete( :topic )
+                block.call( topic, items )
+              end
+            end
+          ensure
+          end
+        end
+      end
+    end
+
+    def listen( *patterns, &block )
+      if block.nil?
+        listen_once( *patterns )
+      else
+        listen_each( *patterns ) do |topic, items|
+          block.call( topic, items )
+        end
+      end
+    end
+
+    def unlisten( **patterns )
+      patterns.each do |pattern|
+        @threads[pattern].kill    rescue  nil
+        @threads.delete( pattern )    rescue  nil
+      end
+    end
+
+    def notify( topic, **items )
+      items[:topic]  =  topic
+      @event_queue.insert_one( items )
+    end
+
+  end
+
+end
+

data/lib/message_channel/mqtt.rb

@@ -0,0 +1,79 @@
+require  "mqtt"
+require  "json"
+
+module MessageChannel
+  class Mqtt
+
+    def initialize( host: nil, port: nil )
+      @host  =  host  || "127.0.0.1"
+      @port  =  ( port  ||  1883 ).to_i
+      @mqtt  =  MQTT::Client.connect( @host, @port )
+      @threads  =  {}
+    end
+
+    def listen_once( *patterns )
+      queue  =  Queue.new
+      threads  =  {}
+      patterns.each do |pattern|
+        threads[pattern]  =  ::Thread.start(pattern) do |pattern|
+          mqtt  =  MQTT::Client.connect( @host, @port )
+          begin
+            mqtt.get( pattern ) do |topic, message|
+              items  =  JSON.parse( message, symbolize_names: true )
+              mqtt.disconnect    rescue  nil
+              queue.push  [topic, items]
+            end
+          ensure
+          end
+        end
+      end
+
+      topic, items  =  queue.pop
+      patterns.each do |pattern|
+        threads[pattern].kill    rescue  nil
+        threads.delete( pattern )    rescue  nil
+      end
+      [topic, items]
+    end
+
+    def listen_each( *patterns, &block )
+      patterns.each do |pattern|
+        @threads[pattern]  =  ::Thread.start(pattern) do |pattern|
+          mqtt  =  MQTT::Client.connect( @host, @port )
+          begin
+            mqtt.get( pattern ) do |topic, message|
+              items  =  JSON.parse( message, symbolize_names: true )
+              block.call( topic, items )
+            end
+          ensure
+            mqtt.disconnect    rescue  nil
+          end
+        end
+      end
+    end
+
+    def listen( *patterns, &block )
+      if block.nil?
+        listen_once( *patterns )
+      else
+        listen_each( *patterns ) do |topic, items|
+          block.call( topic, items )
+        end
+      end
+    end
+
+    def unlisten( **patterns )
+      patterns.each do |pattern|
+        @threads[pattern].kill    rescue  nil
+        @threads.delete( pattern )    rescue  nil
+      end
+    end
+
+    def notify( topic, **items )
+      @mqtt.publish( topic, items.to_json, false )
+    end
+
+  end
+
+end
+