mimi-messaging 1.1.0 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54a536d257b3a394b605e80e1b24167e5912f785
-  data.tar.gz: 03374246a36903692068863563ec7a111cd18b8b
+  metadata.gz: b8baee68b3135998131486589ca0fc56b3454c5e
+  data.tar.gz: 469dc284417b30a83c13a84b7035076cefc8dc64
 SHA512:
-  metadata.gz: '0295bb31beb00e6370340e4db43bab2a145e9d463d514bcdf1eba944a171edb614133afc7384a9e1e3010b832c4ff4b547ae9a27e307efb19d4abe3acee0782d'
-  data.tar.gz: 5e3a7f512fc58d688551c9601c26b863872dfeafaf860554796f2493ba30234045c591520c453fa973cae529069516cc19653553cf369eca7f31bc7c5ac29395
+  metadata.gz: cfab8d964275ca42ce5334212e95bde2808bc0874390bea45602f906c4cf5c7e05cc60d25d3a198a6ee7c6b1935fbfd7416480429cedce5104a8ad8f26f7a5de
+  data.tar.gz: 66d91dcf023f0255384bee9805f0228a445f48109ba751b57d16d38a8798535cfe01dee459a40be41af6c3d6f1711a87c8c4894bc4fca2c007c037f6be28aa0f

data/README.md

@@ -57,7 +57,7 @@ there are several available adapters:
 * [Kafka](https://github.com/kukushkin/mimi-messaging-kafka)
 * RabbitMQ (TBD)
 * NATS (TBD)
-* Amazon SQS/SNS
+* [Amazon SQS/SNS](https://github.com/kukushkin/mimi-messaging-sqs_sns)
 * in-memory (single process)
 
 ## Designing apps
@@ -65,10 +65,11 @@ there are several available adapters:
 
 There are only two hard problems in distributed systems:
 
+```
 2. Exactly-once delivery
 1. Guaranteed order of messages
 2. Exactly-once delivery
-
+```
 
 ## License
 

data/lib/mimi/messaging.rb

@@ -14,14 +14,25 @@ module Mimi
   # Usage: [TBD]
   #
   module Messaging
-    # Target validation pattern:
-    # "[<name>.][...]<name>/<name>"
-    # Where <name> consists of valid identifier characters: A-Za-z0-9_
+    # Request target validation pattern:
+    # "[<name>.][...]<name>/<identifier>"
+    # Where <name> consists of characters: A-Za-z0-9_-
+    # and <method_name> can be any of: A-Za-z0-9_
     #
     # Example:
     # "shop.orders/list"
     #
-    TARGET_REGEX = %r{^((\w+)\.)*(\w+)\/(\w+)$}.freeze
+    REQUEST_TARGET_REGEX = %r{^([\w\-]+\.)*([\w\-]+)\/(\w+)$}.freeze
+
+    # Event target validation pattern:
+    # "[<name>.][...]<name>#<identifier>"
+    # Where <name> consists of characters: A-Za-z0-9_-
+    # and <method_name> can be any of: A-Za-z0-9_
+    #
+    # Example:
+    # "shop.orders#created"
+    #
+    EVENT_TARGET_REGEX = %r{^([\w\-]+\.)*([\w\-]+)\#(\w+)$}.freeze
 
     # By default Mimi::Messaging logs at given level
     DEFAULT_LOG_AT_LEVEL = :info
@@ -179,13 +190,13 @@ module Mimi
     #   Mimi::Messaging.command("users/create", name: "John Smith")
     #
     # @param target [String] "<queue>/<method>"
-    # @param message [Hash]
+    # @param message [Hash,Mimi::Messaging::Message]
     # @param opts [Hash] additional adapter-specific options
     #
     # @return nil
     #
     def self.command(target, message = {}, opts = {})
-      raise ArgumentError, "Invalid target argument" unless TARGET_REGEX.match(target)
+      raise ArgumentError, "Invalid target argument" unless REQUEST_TARGET_REGEX.match(target)
       raise ArgumentError, "Invalid message, Hash or Message is expected" unless message.is_a?(Hash)
       raise Error, "Failed to send command, adapter is not started" unless started?(:adapter)
 
@@ -196,6 +207,9 @@ module Mimi
     #
     # Raises Timeout::Error if the response from the target was not received in time.
     #
+    # Example:
+    #   result = Mimi::Messaging.query("users/find", id: 157)
+    #
     # @param target [String] "<queue>/<method>"
     # @param message [Hash,Mimi::Messaging::Message]
     # @param opts [Hash] additional options, e.g. :timeout
@@ -203,7 +217,7 @@ module Mimi
     # @return [Hash]
     #
     def self.query(target, message = {}, opts = {})
-      raise ArgumentError, "Invalid target argument" unless TARGET_REGEX.match(target)
+      raise ArgumentError, "Invalid target argument" unless REQUEST_TARGET_REGEX.match(target)
       raise ArgumentError, "Invalid message, Hash or Message is expected" unless message.is_a?(Hash)
       raise Error, "Failed to send query, adapter is not started" unless started?(:adapter)
 
@@ -212,12 +226,12 @@ module Mimi
 
     # Broadcasts the event with the given target
     #
-    # @param target [String] "<topic>/<event_type>", e.g. "customers/created"
-    # @param message [Hash]
+    # @param target [String] "<topic>#<event_type>", e.g. "customers#created"
+    # @param message [Hash,Mimi::Messaging::Message]
     # @param opts [Hash] additional options
     #
     def self.event(target, message = {}, opts = {})
-      raise ArgumentError, "Invalid target argument" unless TARGET_REGEX.match(target)
+      raise ArgumentError, "Invalid target argument" unless EVENT_TARGET_REGEX.match(target)
       raise ArgumentError, "Invalid message, Hash or Message is expected" unless message.is_a?(Hash)
       raise Error, "Failed to broadcast event, adapter is not started" unless started?(:adapter)
 
@@ -450,6 +464,7 @@ module Mimi
     def self.stop_all_processors
       log "#{self} stopping all message processors"
       adapter.stop_all_processors
+      message_processors.each { |p| p[:started] = false }
     end
     private_class_method :stop_all_processors
 

data/lib/mimi/messaging/adapters/base.rb

@@ -63,7 +63,7 @@ module Mimi
         # Sends the command to the given target
         #
         # @param target [String] "<queue>/<method>"
-        # @param message [Hash]
+        # @param message [Mimi::Messaging::Message]
         # @param opts [Hash] additional options
         #
         # @return nil
@@ -76,7 +76,7 @@ module Mimi
         # Executes the query to the given target and returns response
         #
         # @param target [String] "<queue>/<method>"
-        # @param message [Hash]
+        # @param message [Mimi::Messaging::Message]
         # @param opts [Hash] additional options, e.g. :timeout
         #
         # @return [Hash]
@@ -88,8 +88,8 @@ module Mimi
 
         # Broadcasts the event with the given target
         #
-        # @param target [String] "<topic>/<event_type>", e.g. "customers/created"
-        # @param message [Hash]
+        # @param target [String] "<topic>#<event_type>", e.g. "customers#created"
+        # @param message [Mimi::Messaging::Message]
         # @param opts [Hash] additional options
         #
         def event(_target, _message, _opts = {})
@@ -124,7 +124,7 @@ module Mimi
           raise(
             ArgumentError,
             "Invalid request processor passed to #{self.class}##{__method__}(), " \
-            "expected to respond to #call_command(...) AND #call_query(method_name, request, opts)"
+            "expected to respond to #call_command(method_name, message, opts) AND #call_query(...)"
           )
         end
 
@@ -149,7 +149,7 @@ module Mimi
           raise(
             ArgumentError,
             "Invalid event processor passed to #{self.class}##{__method__}(), " \
-            "expected to respond to #call_event(method_name, request, opts)"
+            "expected to respond to #call_event(event_type, message, opts)"
           )
         end
 
@@ -175,7 +175,7 @@ module Mimi
           raise(
             ArgumentError,
             "Invalid event processor passed to #{self.class}##{__method__}(), " \
-            "expected to respond to #call_event(method_name, request, opts)"
+            "expected to respond to #call_event(event_type, message, opts)"
           )
         end
 

data/lib/mimi/messaging/adapters/memory.rb

@@ -23,21 +23,39 @@ module Mimi
         def stop
         end
 
+        # Sends COMMAND to target
+        #
+        # @param target [String]
+        # @param message [Mimi::Messaging::Message]
+        # @param opts [Hash]
+        #
         def command(target, message, opts = {})
-          message_serialized = serialize(message)
-          dispatch_command(target, message_serialized, opts)
+          raise ArgumentError, "Message is expected" unless message.is_a?(Mimi::Messaging::Message)
+          dispatch_command(target, message, opts)
           nil
         end
 
+        # Sends QUERY to target
+        #
+        # @param target [String]
+        # @param message [Mimi::Messaging::Message]
+        # @param opts [Hash]
+        #
         def query(target, message, opts = {})
-          message_serialized = serialize(message)
-          response_serialized = dispatch_query(target, message_serialized, opts)
+          raise ArgumentError, "Message is expected" unless message.is_a?(Mimi::Messaging::Message)
+          response_serialized = dispatch_query(target, message, opts)
           deserialize(response_serialized)
         end
 
+        # Sends EVENT to target
+        #
+        # @param target [String]
+        # @param message [Mimi::Messaging::Message]
+        # @param opts [Hash]
+        #
         def event(target, message, opts = {})
-          message_serialized = serialize(message)
-          dispatch_event(target, message_serialized, opts)
+          raise ArgumentError, "Message is expected" unless message.is_a?(Mimi::Messaging::Message)
+          dispatch_event(target, message, opts)
         end
 
         def start_request_processor(queue_name, processor, _opts = {})
@@ -67,38 +85,48 @@ module Mimi
 
         private
 
-        def dispatch_command(target, message_serialized, _opts = {})
+        # Simulates a transmitted message, following serialization/deserialization:
+        #   message out -> message in
+        #
+        # @param message [Mimi::Messaging::Message]
+        # @return [Mimi::Messaging::Message]
+        #
+        def transmitted_message(message)
+          Mimi::Messaging::Message.new(
+            deserialize(serialize(message)),
+            message.headers
+          )
+        end
+
+        def dispatch_command(target, message, _opts = {})
           queue_name, method_name = target.split("/")
-          message = deserialize(message_serialized)
           return unless request_processors[queue_name]
 
           # pick random processor serving the target
           processor = request_processors[queue_name].sample
-          processor.call_command(method_name, message, {})
+          processor.call_command(method_name, transmitted_message(message), {})
         end
 
-        def dispatch_query(target, message_serialized, _opts = {})
+        def dispatch_query(target, message, _opts = {})
           queue_name, method_name = target.split("/")
-          message = deserialize(message_serialized)
           raise Timeout::Error unless request_processors[queue_name]
 
           # pick random processor serving the target
           processor = request_processors[queue_name].sample
-          response = processor.call_query(method_name, message, {})
+          response = processor.call_query(method_name, transmitted_message(message), {})
           serialize(response)
         end
 
         def dispatch_event(target, message_serialized, _opts = {})
-          topic_name, event_type = target.split("/")
+          topic_name, event_type = target.split("#")
           processors = event_processors[topic_name] || []
           processor_queues = event_processors_with_queue[topic_name] || {}
           processor_queues.values.each do |same_queue_processors|
             processors << same_queue_processors.sample
           end
 
-          message = deserialize(message_serialized)
           processors.each do |processor|
-            processor.call_event(event_type, message, {})
+            processor.call_event(event_type, transmitted_message(message), {})
           end
         end
 

data/lib/mimi/messaging/version.rb

@@ -2,6 +2,6 @@
 
 module Mimi
   module Messaging
-    VERSION = "1.1.0"
+    VERSION = "1.2.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mimi-messaging
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.4
 platform: ruby
 authors:
 - Alex Kukushkin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-08 00:00:00.000000000 Z
+date: 2019-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mimi-core