evt-message_store-postgres 1.2.0.0 → 2.4.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77c708beeefed6f49a2a8df231fc7d8bb84ef2dd75982dc602cb5b6893662869
-  data.tar.gz: 3255fa00e94215b04d61fac3054ad4db43e64813c266232cf333e79345d7f49d
+  metadata.gz: d39147eb9243bc55ac8f717ea66848d8f52afa81e2765c65fbcb6d8790eddebd
+  data.tar.gz: c06dbbfd0bdf1755bba528431be09cdf6102e55895c6310f791ded9bdf6fe6f1
 SHA512:
-  metadata.gz: 6b1e8f43a95d701db50f9c21964a52acebe8c435b11c91befb6a0e1c1cdf25b8a33f50d0457f1a4af0f34cfd6d426eb2bd918fef8c953af4deabd861a45ee0a4
-  data.tar.gz: 5e63109d9eb4a60f9c2af6c50ee4adca1929fd224defbe558d47e96c5264ebb884553235cbf5962f9f3d1575fefa9f49ec58d10f4795143ba160a94a9dad67a4
+  metadata.gz: bc425933b84429dfcb09460747dd41b46e652da2b93dcad021759109c8756dcd8bf63b99b300d09200e364559e3220cf03e84e4746cbe8d4716409dac85ec765
+  data.tar.gz: a1834321e541d178d01a302b42c82d4d6f344fc51a47eaba2e6ffeecfaa1f63315e87f979de0c7d1edb3c405da6a5dd6309e8dbc23ac40f6ddfe72f3d6b2f4d2

data/lib/message_store/postgres.rb

@@ -15,7 +15,10 @@ require 'message_store/postgres/put'
 require 'message_store/postgres/write'
 
 require 'message_store/postgres/get'
+require 'message_store/postgres/get/condition'
 require 'message_store/postgres/get/stream'
-require 'message_store/postgres/get/category'
 require 'message_store/postgres/get/stream/last'
+require 'message_store/postgres/get/category'
+require 'message_store/postgres/get/category/correlation'
+require 'message_store/postgres/get/category/consumer_group'
 require 'message_store/postgres/read'

data/lib/message_store/postgres/controls/category.rb

@@ -1,25 +1,7 @@
 module MessageStore
   module Postgres
     module Controls
-      module Category
-        def self.example(category: nil, randomize_category: nil)
-          if randomize_category.nil?
-            if !category.nil?
-              randomize_category = false
-            end
-          end
-
-          randomize_category = true if randomize_category.nil?
-
-          category ||= 'test'
-
-          if randomize_category
-            category = "#{category}#{SecureRandom.hex(16)}XX"
-          end
-
-          category
-        end
-      end
+      Category = MessageStore::Controls::Category
     end
   end
 end

data/lib/message_store/postgres/controls/message_data.rb

@@ -6,19 +6,19 @@ module MessageStore
       module MessageData
         module Write
           module List
-            Entry = Struct.new(:stream_name, :message_data)
+            Entry = Struct.new(:stream_name, :category, :message_data)
 
-            def self.get(instances: nil)
+            def self.get(instances: nil, stream_name: nil, category: nil)
               instances ||= 1
 
-              stream_name = StreamName.example
-
               list = []
               instances.times do
-                stream_name = Controls::StreamName.example
+                instance_stream_name = stream_name || StreamName.example(category: category)
+                instance_category = MessageStore::StreamName.get_category(instance_stream_name)
+
                 write_message = Controls::MessageData::Write.example
 
-                list << Entry.new(stream_name, write_message)
+                list << Entry.new(instance_stream_name, instance_category, write_message)
               end
 
               list

data/lib/message_store/postgres/controls/put.rb

@@ -2,20 +2,21 @@ module MessageStore
   module Postgres
     module Controls
       module Put
-        def self.call(instances: nil, stream_name: nil, message: nil, category: nil)
+        def self.call(instances: nil, stream_name: nil, message_data: nil, message: nil, category: nil)
           instances ||= 1
           stream_name ||= StreamName.example(category: category)
+          message_data ||= message
 
-          message_specified = !message.nil?
+          message_specified = !message_data.nil?
 
-          message ||= MessageData::Write.example
+          message_data ||= MessageData::Write.example
 
           position = nil
           instances.times do
-            position = MessageStore::Postgres::Put.(message, stream_name)
+            position = MessageStore::Postgres::Put.(message_data, stream_name)
 
             unless message_specified
-              message.id = MessageData::Write.id
+              message_data.id = MessageData::Write.id
             end
           end
 

data/lib/message_store/postgres/get.rb

@@ -4,14 +4,21 @@ module MessageStore
       def self.included(cls)
         cls.class_exec do
           include MessageStore::Get
+
           prepend Call
           prepend BatchSize
 
-          extend SQLCommand
-
           dependency :session, Session
 
-          initializer :stream_name, na(:batch_size), :condition
+          abstract :stream_name
+          abstract :sql_command
+          abstract :parameters
+          abstract :parameter_values
+          abstract :last_position
+          abstract :log_text
+
+          virtual :specialize_error
+          virtual :assure
         end
       end
 
@@ -21,40 +28,44 @@ module MessageStore
         end
       end
 
-      def self.build(stream_name, batch_size: nil, session: nil, condition: nil)
+      def self.build(stream_name, **args)
         cls = specialization(stream_name)
-
-        cls.new(stream_name, batch_size, condition).tap do |instance|
-          instance.configure(session: session)
-        end
+        cls.build(stream_name, **args)
       end
 
-      def self.configure(receiver, stream_name, attr_name: nil, batch_size: nil, condition: nil, session: nil)
+      def self.configure(receiver, stream_name, **args)
+        attr_name = args.delete(:attr_name)
         attr_name ||= :get
-        instance = build(stream_name, batch_size: batch_size, condition: condition, session: session)
-        receiver.public_send "#{attr_name}=", instance
+
+        instance = build(stream_name, **args)
+        receiver.public_send("#{attr_name}=", instance)
       end
 
       def configure(session: nil)
-        Session.configure self, session: session
+        Session.configure(self, session: session)
       end
 
-      def self.call(stream_name, position: nil, batch_size: nil, condition: nil,  session: nil)
-        instance = build(stream_name, batch_size: batch_size, condition: condition, session: session)
+      def self.call(stream_name, **args)
+        position = args.delete(:position)
+        instance = build(stream_name, **args)
         instance.(position)
       end
 
       module Call
-        def call(position)
-          logger.trace(tag: :get) { "Getting message data (Stream Name: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect})" }
+        def call(position=nil, stream_name: nil)
+          position ||= self.class::Defaults.position
+
+          stream_name ||= self.stream_name
+
+          assure
 
-          position ||= Defaults.position
+          logger.trace(tag: :get) { "Getting message data (#{log_text(stream_name, position)})" }
 
           result = get_result(stream_name, position)
 
           message_data = convert(result)
 
-          logger.info(tag: :get) { "Finished getting message data (Count: #{message_data.length}, Stream Name: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect})" }
+          logger.info(tag: :get) { "Finished getting message data (Count: #{message_data.length}, #{log_text(stream_name, position)})" }
           logger.info(tags: [:data, :message_data]) { message_data.pretty_inspect }
 
           message_data
@@ -62,53 +73,60 @@ module MessageStore
       end
 
       def get_result(stream_name, position)
-        logger.trace(tag: :get) { "Getting result (Stream Name: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect}, Condition: #{condition || '(none)'})" }
+        logger.trace(tag: :get) { "Getting result (#{log_text(stream_name, position)})" }
 
-        sql_command = self.class.sql_command(stream_name, position, batch_size, condition)
+        parameter_values = parameter_values(stream_name, position)
 
-        cond = Get.constrain_condition(condition)
-
-        params = [
-          stream_name,
-          position,
-          batch_size,
-          cond
-        ]
-
-        result = session.execute(sql_command, params)
+        begin
+          result = session.execute(sql_command, parameter_values)
+        rescue PG::RaiseException => e
+          raise_error(e)
+        end
 
-        logger.debug(tag: :get) { "Finished getting result (Count: #{result.ntuples}, Stream Name: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect}, Condition: #{condition || '(none)'})" }
+        logger.debug(tag: :get) { "Finished getting result (Count: #{result.ntuples}, #{log_text(stream_name, position)})" }
 
         result
       end
 
-      def self.constrain_condition(condition)
-        return nil if condition.nil?
+      def convert(result)
+        logger.trace(tag: :get) { "Converting result to message data (Result Count: #{result.ntuples})" }
+
+        message_data = result.map do |record|
+          Get.message_data(record)
+        end
 
-        "(#{condition})"
+        logger.debug(tag: :get) { "Converted result to message data (Message Data Count: #{message_data.length})" }
+
+        message_data
       end
 
-      module SQLCommand
-        def sql_command(stream_name, position, batch_size, condition)
-          parameters = '$1::varchar, $2::bigint, $3::bigint, $4::varchar'
-          command_text(parameters)
-        end
+      def self.message_data(record)
+        record['data'] = Get::Deserialize.data(record['data'])
+        record['metadata'] = Get::Deserialize.metadata(record['metadata'])
+        record['time'] = Get::Time.utc_coerced(record['time'])
+
+        MessageData::Read.build(record)
       end
 
-      def convert(result)
-        logger.trace(tag: :get) { "Converting result to message data (Result Count: #{result.ntuples})" }
+      def raise_error(pg_error)
+        error_message = Get.error_message(pg_error)
 
-        message_data = result.map do |record|
-          record['data'] = Deserialize.data(record['data'])
-          record['metadata'] = Deserialize.metadata(record['metadata'])
-          record['time'] = Time.utc_coerced(record['time'])
+        error = Condition.error(error_message)
 
-          MessageData::Read.build(record)
+        if error.nil?
+          error = specialize_error(error_message)
         end
 
-        logger.debug(tag: :get) { "Converted result to message data (Message Data Count: #{message_data.length})" }
+        if not error.nil?
+          logger.error { error_message }
+          raise error
+        end
 
-        message_data
+        raise pg_error
+      end
+
+      def self.error_message(pg_error)
+        pg_error.message.gsub('ERROR:', '').strip
       end
 
       def self.specialization(stream_name)
@@ -138,10 +156,6 @@ module MessageStore
       end
 
       module Defaults
-        def self.position
-          0
-        end
-
         def self.batch_size
           1000
         end

data/lib/message_store/postgres/get/category.rb

@@ -2,15 +2,79 @@ module MessageStore
   module Postgres
     module Get
       class Category
+        Error = Class.new(RuntimeError)
+
         include Get
 
-        def self.command_text(parameters)
+        initializer :category, na(:batch_size), :correlation, :consumer_group_member, :consumer_group_size, :condition
+        alias :stream_name :category
+
+        def self.call(category, position: nil, batch_size: nil, correlation: nil, consumer_group_member: nil, consumer_group_size: nil, condition: nil, session: nil)
+          instance = build(category, batch_size: batch_size, correlation: correlation, consumer_group_member: consumer_group_member, consumer_group_size: consumer_group_size, condition: condition, session: session)
+          instance.(position)
+        end
+
+        def self.build(category, batch_size: nil, correlation: nil, consumer_group_member: nil, consumer_group_size: nil, condition: nil, session: nil)
+          instance = new(category, batch_size, correlation, consumer_group_member, consumer_group_size, condition)
+          instance.configure(session: session)
+          instance
+        end
+
+        def self.configure(receiver, category, attr_name: nil, batch_size: nil, correlation: nil, consumer_group_member: nil, consumer_group_size: nil, condition: nil, session: nil)
+          attr_name ||= :get
+          instance = build(category, batch_size: batch_size, correlation: correlation, consumer_group_member: consumer_group_member, consumer_group_size: consumer_group_size, condition: condition, session: session)
+          receiver.public_send("#{attr_name}=", instance)
+        end
+
+        def sql_command
           "SELECT * FROM get_category_messages(#{parameters});"
         end
 
+        def parameters
+          '$1::varchar, $2::bigint, $3::bigint, $4::varchar, $5::bigint, $6::bigint, $7::varchar'
+        end
+
+        def parameter_values(category, position)
+          [
+            category,
+            position,
+            batch_size,
+            correlation,
+            consumer_group_member,
+            consumer_group_size,
+            condition
+          ]
+        end
+
         def last_position(batch)
           batch.last.global_position
         end
+
+        def specialize_error(error_message)
+          error = Correlation.error(error_message)
+
+          if error.nil?
+            error = ConsumerGroup.error(error_message)
+          end
+
+          error
+        end
+
+        def log_text(category, position)
+          "Category: #{category}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect}, Correlation: #{correlation.inspect}, Consumer Group Member: #{consumer_group_member.inspect}, Consumer Group Size: #{consumer_group_size.inspect}, Condition: #{condition.inspect})"
+        end
+
+        def assure
+          if not MessageStore::StreamName.category?(category)
+            raise Error, "Must be a category (Stream Name: #{category})"
+          end
+        end
+
+        module Defaults
+          def self.position
+            1
+          end
+        end
       end
     end
   end

data/lib/message_store/postgres/get/category/consumer_group.rb

@@ -0,0 +1,20 @@
+module MessageStore
+  module Postgres
+    module Get
+      class Category
+        module ConsumerGroup
+          Error = Class.new(RuntimeError)
+
+          def self.error(error_message)
+            if error_message.start_with?('Consumer group size must not be less than 1') ||
+                error_message.start_with?('Consumer group member must be less than the group size') ||
+                error_message.start_with?('Consumer group member must not be less than 0') ||
+                error_message.start_with?('Consumer group member and size must be specified')
+              Error.new(error_message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/category/correlation.rb

@@ -0,0 +1,17 @@
+module MessageStore
+  module Postgres
+    module Get
+      class Category
+        module Correlation
+          Error = Class.new(RuntimeError)
+
+          def self.error(error_message)
+            if error_message.start_with?('Correlation must be a category')
+              Error.new(error_message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/condition.rb

@@ -0,0 +1,15 @@
+module MessageStore
+  module Postgres
+    module Get
+      module Condition
+        Error = Class.new(RuntimeError)
+
+        def self.error(error_message)
+          if error_message.start_with?('Retrieval with SQL condition is not activated')
+            Get::Condition::Error.new(error_message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/stream.rb

@@ -2,15 +2,65 @@ module MessageStore
   module Postgres
     module Get
       class Stream
+        Error = Class.new(RuntimeError)
+
         include Get
 
-        def self.command_text(parameters)
+        initializer :stream_name, na(:batch_size), :condition
+
+        def self.call(stream_name, position: nil, batch_size: nil, condition: nil, session: nil)
+          instance = build(stream_name, batch_size: batch_size, condition: condition, session: session)
+          instance.(position)
+        end
+
+        def self.build(stream_name, batch_size: nil, condition: nil, session: nil)
+          instance = new(stream_name, batch_size, condition)
+          instance.configure(session: session)
+          instance
+        end
+
+        def self.configure(receiver, stream_name, attr_name: nil, batch_size: nil, condition: nil, session: nil)
+          attr_name ||= :get
+          instance = build(stream_name, batch_size: batch_size, condition: condition, session: session)
+          receiver.public_send("#{attr_name}=", instance)
+        end
+
+        def sql_command
           "SELECT * FROM get_stream_messages(#{parameters});"
         end
 
+        def parameters
+          '$1::varchar, $2::bigint, $3::bigint, $4::varchar'
+        end
+
+        def parameter_values(stream_name, position)
+          [
+            stream_name,
+            position,
+            batch_size,
+            condition
+          ]
+        end
+
         def last_position(batch)
           batch.last.position
         end
+
+        def log_text(stream_name, position)
+          "Stream Name: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect}, Condition: #{condition.inspect})"
+        end
+
+        def assure
+          if MessageStore::StreamName.category?(stream_name)
+            raise Error, "Must be a stream name (Category: #{stream_name})"
+          end
+        end
+
+        module Defaults
+          def self.position
+            0
+          end
+        end
       end
     end
   end

data/lib/message_store/postgres/get/stream/last.rb

@@ -31,11 +31,11 @@ module MessageStore
 
             sql_command = self.class.sql_command(stream_name)
 
-            params = [
+            parameter_values = [
               stream_name
             ]
 
-            result = session.execute(sql_command, params)
+            result = session.execute(sql_command, parameter_values)
 
             logger.debug(tag: :get) { "Finished getting result (Count: #{result.ntuples}, Stream: #{stream_name}" }
 
@@ -47,40 +47,18 @@ module MessageStore
           def self.sql_command(stream_name)
             parameters = '$1::varchar'
 
-            "SELECT * FROM get_last_message(#{parameters});"
+            "SELECT * FROM get_last_stream_message(#{parameters});"
           end
 
           def convert(record)
             logger.trace(tag: :get) { "Converting record to message data" }
 
-            record['data'] = Deserialize.data(record['data'])
-            record['metadata'] = Deserialize.metadata(record['metadata'])
-            record['time'] = Time.utc_coerced(record['time'])
-
-            message_data = MessageData::Read.build(record)
+            message_data = Get.message_data(record)
 
             logger.debug(tag: :get) { "Converted record to message data" }
 
             message_data
           end
-
-          module Deserialize
-            def self.data(serialized_data)
-              return nil if serialized_data.nil?
-              Transform::Read.(serialized_data, :json, MessageData::Hash)
-            end
-
-            def self.metadata(serialized_metadata)
-              return nil if serialized_metadata.nil?
-              Transform::Read.(serialized_metadata, :json, MessageData::Hash)
-            end
-          end
-
-          module Time
-            def self.utc_coerced(local_time)
-              Clock::UTC.coerce(local_time)
-            end
-          end
         end
       end
     end

data/lib/message_store/postgres/put.rb

@@ -5,7 +5,7 @@ module MessageStore
       include Log::Dependency
 
       dependency :session, Session
-      dependency :identifier, Session
+      dependency :identifier, Identifier::UUID::RandomIdentifier dependency is corrected
 
       def self.build(session: nil)
         new.tap do |instance|

data/lib/message_store/postgres/settings.rb

@@ -6,7 +6,7 @@ module MessageStore
       end
 
       def self.data_source
-        Defaults.data_source || 'settings/message_store_postgres.json'
+        Defaults.data_source
       end
 
       def self.names
@@ -28,7 +28,7 @@ module MessageStore
 
       class Defaults
         def self.data_source
-          ENV['MESSAGE_STORE_SETTINGS_PATH']
+          ENV['MESSAGE_STORE_SETTINGS_PATH'] || 'settings/message_store_postgres.json'
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evt-message_store-postgres
 version: !ruby/object:Gem::Version
-  version: 1.2.0.0
+  version: 2.4.0.3
 platform: ruby
 authors:
 - The Eventide Project
 autorequire: 
 bindir: scripts
 cert_chain: []
-date: 2019-11-01 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: evt-message_store
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: evt-message_store-postgres-database
+  name: evt-log
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: evt-log
+  name: evt-settings
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: evt-settings
+  name: message-db
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -137,6 +137,9 @@ files:
 - lib/message_store/postgres/controls/stream_name.rb
 - lib/message_store/postgres/get.rb
 - lib/message_store/postgres/get/category.rb
+- lib/message_store/postgres/get/category/consumer_group.rb
+- lib/message_store/postgres/get/category/correlation.rb
+- lib/message_store/postgres/get/condition.rb
 - lib/message_store/postgres/get/stream.rb
 - lib/message_store/postgres/get/stream/last.rb
 - lib/message_store/postgres/log.rb
@@ -164,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Message store implementation for PostgreSQL