cyclone_lariat 0.2.3 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a416593e31f7f6fd67eb7e453971b5867d9169bdb37e5708876fdea03b8021f
-  data.tar.gz: 6ba164622a11d2bd4d63214ba391372bfda1c5447d8979332ef66a4e9e9d2c75
+  metadata.gz: 3fe1faa17fac474b04c873eb81272506724e8ac3ac23e18549b2f63287174e97
+  data.tar.gz: d645f4859619af32a96448a8357aaf08c6ffc31e1138666df149e44284e00389
 SHA512:
-  metadata.gz: b7fe001ac8bfc6f373d2f9e7eeb8be68bdea77bca68d4c7b9a7af36c41fd606e82fff5355fc0757e6b4c0b8ca7b00798a7f90c47b3b1a8d141b519389747a117
-  data.tar.gz: 19f361ff6fa6509439f8aa6122f743175678c81aee9948b71e5f2fb4e3ab8f852b86920fdcbd656c16a3ac1c30705c4da96c542c2e4a373ab012040544128049
+  metadata.gz: 4acacb0d92e72eb15a7247f04e06ad171935f3ab54da976a3427aec45af35beac28f7ce2bbfd79213ce7331cf07541bc7d4a839ff44fc0c76359119b5e341503
+  data.tar.gz: 23b2bc0a32aa5b10392392249f4f23ee8db12edaafd994fd5505b854da3a5f8773f5d101e972678d6e8c33b74bde1f5a2ab4d68ff757852c513e409c5de9bf89

data/.gitignore

@@ -9,7 +9,7 @@
 /tmp/
 /.tmp/
 .byebug_history
-config/database.yml
+config/db.rb
 
 # rspec failure tracking
 .rspec_status

data/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.3] - 2021-07-14
+Changed
+- Bugfix of message equality check
+
+## [0.3.2] - 2021-06-11
+Changed
+- Bugfix
+
+## [0.3.1] - 2021-06-11
+Changed
+- Command
+- SqsClient
+
+## [0.3.0] - 2021-06-09
+Added
+- Command
+- SqsClient
+
+Changed:
+- Client renamed to SnsClient
+- `to:` renamed to `topic:`
+
 ## [0.2.3] - 2021-06-09
 Added
 - Skip on empty message with error notify

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    cyclone_lariat (0.2.3)
+    cyclone_lariat (0.3.2)
       aws-sdk-sns
+      aws-sdk-sqs
       luna_park (~> 0.11)
 
 GEM
@@ -21,6 +22,9 @@ GEM
     aws-sdk-sns (1.40.0)
       aws-sdk-core (~> 3, >= 3.112.0)
       aws-sigv4 (~> 1.1)
+    aws-sdk-sqs (1.39.0)
+      aws-sdk-core (~> 3, >= 3.112.0)
+      aws-sigv4 (~> 1.1)
     aws-sigv4 (1.2.3)
       aws-eventstream (~> 1, >= 1.0.2)
     byebug (11.1.3)

data/README.md

@@ -19,59 +19,82 @@ gem 'cyclone_lariat'
 
 ![diagram](docs/_imgs/diagram.png)
 
-
-## Client
-
+## Command vs Event
+Commands and events are both simple domain structures that contain solely data for reading. That means they contain no 
+behaviour or business logic.
+
+A command is an object that is sent to the domain for a state change which is handled by a command handler. They should 
+be named with a verb in an imperative mood plus the aggregate name which it operates on. Such request can be rejected 
+due to the data the command holds being invalid/inconsistent. There should be exactly 1 handler for each command. 
+Once the command has been executed, the consumer can then carry out whatever the task is depending on the output of the 
+command.
+
+An event is a statement of fact about what change has been made to the domain state. They are named with the aggregate 
+name where the change took place plus the verb past-participle. An event happens off the back of a command. 
+A command can emit any number of events. The sender of the event does not care who receives it or whether it has been 
+received at all.
+
+## SnsClient
 You can use client directly
 
 ```ruby
-require 'cyclone_lariat/client' # If require: false in Gemfile 
+require 'cyclone_lariat/sns_client' # If require: false in Gemfile 
 
-client = CycloneLariat::Client.new(
-  key:        APP_CONF.aws.key,
+client = CycloneLariat::SnsClient.new(
+  key: APP_CONF.aws.key,
   secret_key: APP_CONF.aws.secret_key,
-  region:     APP_CONF.aws.region,
-  version:    1,                          # at default 1
-  publisher:  'pilot',
-  instance:   INSTANCE                    # at default :prod
+  region: APP_CONF.aws.region,
+  version: 1, # at default 1
+  publisher: 'pilot',
+  instance: INSTANCE # at default :prod
 )
 ```
 
 You can don't define topic, and it's name will be defined automatically 
 ```ruby
                      # event_type        data                                    topic
-client.publish_event 'email_is_created', data: { mail: 'john.doe@example.com' } # prod-event-fanout-pilot-email_is_created
-client.publish_event 'email_is_removed', data: { mail: 'john.doe@example.com' } # prod-event-fanout-pilot-email_is_removed
+client.publish_event   'email_is_created', data: { mail: 'john.doe@example.com' } # prod-event-fanout-pilot-email_is_created
+client.publish_event   'email_is_removed', data: { mail: 'john.doe@example.com' } # prod-event-fanout-pilot-email_is_removed
+client.publish_command 'delete_user',      data: { mail: 'john.doe@example.com' } # prod-command-fanout-pilot-delete_user
 ```
 Or you can define it by handle. For example, if you want to send different events to same channel.
 ```ruby
                      # event_type        data                                    topic
-client.publish_event 'email_is_created', data: { mail: 'john.doe@example.com' }, to: 'prod-event-fanout-pilot-emails'
-client.publish_event 'email_is_removed', data: { mail: 'john.doe@example.com' }, to: 'prod-event-fanout-pilot-emails'
+client.publish_event   'email_is_created', data: { mail: 'john.doe@example.com' }, topic: 'prod-event-fanout-pilot-emails'
+client.publish_event   'email_is_removed', data: { mail: 'john.doe@example.com' }, topic: 'prod-event-fanout-pilot-emails'
+client.publish_command 'delete_user',      data: { mail: 'john.doe@example.com' }, topic: 'prod-command-fanout-pilot-emails'
 ```
 
 Or you can use client as Repo.
 
 ```ruby
-require 'cyclone_lariat/client' # If require: false in Gemfile
+require 'cyclone_lariat/sns_client' # If require: false in Gemfile
 
-class YourClient < CycloneLariat::Client
-  version   1
+class YourClient < CycloneLariat::SnsClient
+  version 1
   publisher 'pilot'
-  instance  'stage'
-  
+  instance 'stage'
+
   def email_is_created(mail)
-    publish event( 'email_is_created', 
-      data: { mail: mail }
-    ), 
-    to: APP_CONF.aws.fanout.emails
+    publish event('email_is_created',
+                  data: { mail: mail }
+            ),
+            to: APP_CONF.aws.fanout.emails
   end
-  
+
   def email_is_removed(mail)
-    publish event( 'email_is_removed', 
-      data: { mail: mail }
-    ), 
-    to: APP_CONF.aws.fanout.email
+    publish event('email_is_removed',
+                  data: { mail: mail }
+            ),
+            to: APP_CONF.aws.fanout.email
+  end
+
+
+  def delete_user(mail)
+    publish command('delete_user',
+                  data: { mail: mail }
+            ),
+            to: APP_CONF.aws.fanout.email
   end
 end
 
@@ -81,8 +104,40 @@ client = YourClient.new(key: APP_CONF.aws.key, secret_key: APP_CONF.aws.secret_k
 # And send topics
 client.email_is_created 'john.doe@example.com'
 client.email_is_removed 'john.doe@example.com'
+client.delete_user      'john.doe@example.com'
 ```
 
+
+# SqsClient
+SqsClient is really similar to SnsClient. It can be initialized in same way:
+
+```ruby
+require 'cyclone_lariat/sns_client' # If require: false in Gemfile 
+
+client = CycloneLariat::SqsClient.new(
+  key: APP_CONF.aws.key,
+  secret_key: APP_CONF.aws.secret_key,
+  region: APP_CONF.aws.region,
+  version: 1, # at default 1
+  publisher: 'pilot',
+  instance: INSTANCE # at default :prod
+)
+```
+
+As you see all params identity. And you can easily change your sqs-queue to sns-topic when you start work with more
+subscribes. But you should define destination.
+
+```ruby
+client.publish_event 'email_is_created', data: { mail: 'john.doe@example.com' }, dest: 'notify_service'  
+# prod-event-queue-pilot-email_is_created-notify_service
+```
+
+Or you can define topic directly:
+```ruby
+client.publish_event 'email_is_created', data: { mail: 'john.doe@example.com' }, topic: 'prod-event-fanout-pilot-emails'
+```
+
+
 # Middleware
 If you use middleware:
 - Store all events to dataset
@@ -104,7 +159,6 @@ class Receiver
                     queue: 'your_sqs_queue_name'
 
   server_middleware do |chain|
-    
     # Options dataset, errors_notifier and message_notifier is optionals.
     # If you dont define notifiers - middleware does not notify
     # If you dont define dataset - middleware does store events in db
@@ -144,7 +198,7 @@ end
 # The second one:
 Sequel.migration do
   change do
-    create_table :events do
+    create_table :async_messages do
       column   :uuid, :uuid, primary_key: true
       String   :type,                         null: false
       Integer  :version,                      null: false

data/cyclone_lariat.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'aws-sdk-sns'
+  spec.add_dependency 'aws-sdk-sqs'
   spec.add_dependency 'luna_park', '~> 0.11'
 
   spec.add_development_dependency 'bundler', '~> 2.1'

data/db/migrate/02_add_events.rb

@@ -2,8 +2,9 @@
 
 Sequel.migration do
   change do
-    create_table :events do
+    create_table :async_messages do
       column   :uuid, :uuid, primary_key: true
+      String   :kind,                        null: false
       String   :type,                        null: false
       Integer  :version,                     null: false
       String   :publisher,                   null: false

data/lib/cyclone_lariat.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'cyclone_lariat/client'
+require_relative 'cyclone_lariat/sns_client'
 require_relative 'cyclone_lariat/errors'
 require_relative 'cyclone_lariat/event'
-require_relative 'cyclone_lariat/events_repo'
+require_relative 'cyclone_lariat/messages_repo'
 require_relative 'cyclone_lariat/middleware'
 require_relative 'cyclone_lariat/version'
 

data/lib/cyclone_lariat/abstract/client.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# require 'aws-sdk-sns'
+require 'luna_park/extensions/injector'
+require_relative '../event'
+require_relative '../command'
+require_relative '../errors'
+
+module CycloneLariat
+  module Abstract
+    class Client
+      include LunaPark::Extensions::Injector
+
+      dependency(:aws_client_class)      { raise ArgumentError, 'Client class should be defined' }
+      dependency(:aws_credentials_class) { Aws::Credentials }
+
+      DEFAULT_VERSION  = 1
+      DEFAULT_INSTANCE = :prod
+
+      def initialize(key:, secret_key:, region:, version: nil, publisher: nil, instance: nil)
+        @key = key
+        @secret_key = secret_key
+        @region = region
+        @version = version
+        @publisher = publisher
+        @instance = instance
+      end
+
+      def event(type, data: {}, version: self.version, uuid: SecureRandom.uuid)
+        Event.wrap(
+          uuid: uuid,
+          type: type,
+          sent_at: Time.now.iso8601,
+          version: version,
+          publisher: publisher,
+          data: data
+        )
+      end
+
+      def command(type, data: {}, version: self.version, uuid: SecureRandom.uuid)
+        Command.wrap(
+          uuid: uuid,
+          type: type,
+          sent_at: Time.now.iso8601,
+          version: version,
+          publisher: publisher,
+          data: data
+        )
+      end
+
+      def publish
+        raise LunaPark::Errors::AbstractMethod, 'Publish method should be defined'
+      end
+
+      class << self
+        def version(version = nil)
+          version.nil? ? @version || DEFAULT_VERSION : @version = version
+        end
+
+        def instance(instance = nil)
+          instance.nil? ? @instance || DEFAULT_INSTANCE : @instance = instance
+        end
+
+        def publisher(publisher = nil)
+          publisher.nil? ? @publisher || (raise 'You should define publisher') : @publisher = publisher
+        end
+      end
+
+      def version
+        @version ||= self.class.version
+      end
+
+      def publisher
+        @publisher ||= self.class.publisher
+      end
+
+      def instance
+        @instance ||= self.class.instance
+      end
+
+      private
+
+      attr_reader :key, :secret_key, :region
+
+      def aws_client
+        @aws_client ||= aws_client_class.new(credentials: aws_credentials, region: region)
+      end
+
+      def aws_credentials
+        @aws_credentials ||= aws_credentials_class.new(key, secret_key)
+      end
+    end
+  end
+end

data/lib/cyclone_lariat/abstract/message.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'luna_park/entities/attributable'
+require_relative '../errors'
+
+module CycloneLariat
+  module Abstract
+    class Message < LunaPark::Entities::Attributable
+      attr :uuid,      String, :new
+      attr :publisher, String, :new
+      attr :type,      String, :new
+      attrs :client_error, :version, :data,
+            :sent_at, :processed_at, :received_at
+
+      def kind
+        raise LunaPark::Errors::AbstractMethod
+      end
+
+      def version=(value)
+        @version = Integer(value)
+      end
+
+      def sent_at=(value)
+        @sent_at = wrap_time(value)
+      end
+
+      def received_at=(value)
+        @received_at = wrap_time(value)
+      end
+
+      def processed_at=(value)
+        @processed_at = wrap_time(value)
+      end
+
+      def processed?
+        !@processed_at.nil?
+      end
+
+      def client_error_message=(txt)
+        return unless txt
+
+        @client_error ||= Errors::ClientError.new
+        @client_error.message = txt
+      end
+
+      def client_error_details=(details)
+        return unless details
+
+        @client_error ||= Errors::ClientError.new
+        @client_error.details = details
+      end
+
+      def ==(other)
+        kind == other.kind &&
+          uuid == other.uuid &&
+          publisher == other.publisher &&
+          type == other.type &&
+          client_error&.message == other.client_error&.message &&
+          client_error&.details == other.client_error&.details &&
+          version == other.version &&
+          sent_at.to_i == other.sent_at.to_i &&
+          received_at.to_i == other.received_at.to_i &&
+          processed_at.to_i == other.processed_at.to_i
+      end
+
+      def to_json(*args)
+        hash = serialize
+        hash[:type] = [kind, hash[:type]].join '_'
+        hash.to_json(*args)
+      end
+
+      private
+
+      def wrap_time(value)
+        case value
+        when String   then Time.parse(value)
+        when Time     then value
+        when NilClass then nil
+        else raise ArgumentError, "Unknown type `#{value.class}`"
+        end
+      end
+    end
+  end
+end

data/lib/cyclone_lariat/command.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/message'
+
+module CycloneLariat
+  class Command < Abstract::Message
+    KIND = 'command'
+
+    def kind
+      KIND
+    end
+  end
+end

data/lib/cyclone_lariat/event.rb

@@ -1,85 +1,13 @@
 # frozen_string_literal: true
 
-require 'luna_park/entities/attributable'
-require_relative 'errors'
+require_relative 'abstract/message'
 
 module CycloneLariat
-  class Event < LunaPark::Entities::Attributable
+  class Event < Abstract::Message
     KIND = 'event'
 
-    attr :uuid,      String, :new
-    attr :publisher, String, :new
-    attr :type,      String, :new
-    attr :client_error
-    attr :version
-    attr :data
-
-    attr_reader :sent_at,
-                :processed_at,
-                :received_at
-
     def kind
       KIND
     end
-
-    def version=(value)
-      @version = Integer(value)
-    end
-
-    def sent_at=(value)
-      @sent_at = wrap_time(value)
-    end
-
-    def received_at=(value)
-      @received_at = wrap_time(value)
-    end
-
-    def processed_at=(value)
-      @processed_at = wrap_time(value)
-    end
-
-    def client_error_message=(txt)
-      return unless txt
-
-      @client_error ||= Errors::ClientError.new
-      @client_error.message = txt
-    end
-
-    def client_error_details=(details)
-      return unless details
-
-      @client_error ||= Errors::ClientError.new
-      @client_error.details = details
-    end
-
-    def ==(other)
-      kind == other.kind &&
-        uuid == other.uuid &&
-        publisher == other.publisher &&
-        type == other.type &&
-        client_error&.message == other.client_error&.message &&
-        client_error&.details == other.client_error&.details &&
-        version == other.version &&
-        sent_at.to_i == other.sent_at.to_i &&
-        received_at.to_i == other.received_at.to_i
-      processed_at.to_i == other.processed_at.to_i
-    end
-
-    def to_json(*args)
-      hash = serialize
-      hash[:type] = [kind, hash[:type]].join '_'
-      hash.to_json(*args)
-    end
-
-    private
-
-    def wrap_time(value)
-      case value
-      when String   then Time.parse(value)
-      when Time     then value
-      when NilClass then nil
-      else raise ArgumentError, "Unknown type `#{value.class}`"
-      end
-    end
   end
 end

data/lib/cyclone_lariat/messages_repo.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'event'
+
+module CycloneLariat
+  class MessagesRepo
+    attr_reader :dataset
+
+    def initialize(dataset)
+      @dataset = dataset
+    end
+
+    def create(msg)
+      dataset.insert(
+        uuid: msg.uuid,
+        kind: msg.kind,
+        type: msg.type,
+        publisher: msg.publisher,
+        data: JSON.generate(msg.data),
+        client_error_message: msg.client_error&.message,
+        client_error_details: JSON.generate(msg.client_error&.details),
+        version: msg.version,
+        sent_at: msg.sent_at
+      )
+    end
+
+    def exists?(uuid:)
+      dataset.where(uuid: uuid).limit(1).any?
+    end
+
+    def processed!(uuid:, error: nil)
+      data = { processed_at: Sequel.function(:NOW) }
+      data.merge!(client_error_message: error.message, client_error_details: JSON.generate(error.details)) if error
+
+      !dataset.where(uuid: uuid).update(data).zero?
+    end
+
+    def find(uuid:)
+      raw = dataset.where(uuid: uuid).first
+      return nil unless raw
+
+      raw[:data] = JSON.parse(raw[:data], symbolize_names: true)
+      if raw[:client_error_details]
+        raw[:client_error_details] = JSON.parse(raw[:client_error_details], symbolize_names: true)
+      end
+      build raw
+    end
+
+    def each_unprocessed
+      dataset.where(processed_at: nil).each do |raw|
+        raw[:data]                 = JSON.parse(raw[:data], symbolize_names: true)
+        if raw[:client_error_details]
+          raw[:client_error_details] = JSON.parse(raw[:client_error_details], symbolize_names: true)
+        end
+        msg = build raw
+        yield(msg)
+      end
+    end
+
+    def each_with_client_errors
+      dataset.where { (processed_at !~ nil) & (client_error_message !~ nil) }.each do |raw|
+        raw[:data] = JSON.parse(raw[:data], symbolize_names: true)
+        if raw[:client_error_details]
+          raw[:client_error_details] = JSON.parse(raw[:client_error_details], symbolize_names: true)
+        end
+        msg = build raw
+        yield(msg)
+      end
+    end
+
+    private
+
+    def build(raw)
+      case kind = raw.delete(:kind)
+      when 'event'   then Event.wrap raw
+      when 'command' then Command.wrap raw
+      else raise ArgumentError, "Unknown kind `#{kind}` of message"
+      end
+    end
+  end
+end

data/lib/cyclone_lariat/middleware.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
-require_relative 'events_repo'
+require_relative 'messages_repo'
 require 'luna_park/errors'
 require 'json'
 
 module CycloneLariat
   class Middleware
-    def initialize(dataset: nil, errors_notifier: nil, message_notifier: nil, repo: EventsRepo)
+    def initialize(dataset: nil, errors_notifier: nil, message_notifier: nil, repo: MessagesRepo)
       @events_repo      = repo.new(dataset) if dataset
       @message_notifier = message_notifier
       @errors_notifier  = errors_notifier
     end
 
     def call(_worker_instance, queue, _sqs_msg, body, &block)
-      log_received_message queue, body
+      msg = receive_message(body)
 
-      catch_standard_error(queue, body) do
-        return true unless check(body[:Message])
-        
-        event = Event.wrap(JSON.parse(body[:Message]))
+      message_notifier&.info 'Receive message', message: msg, queue: queue
 
-        catch_business_error(event) do
-          store_in_dataset(event, &block)
+      catch_standard_error(queue, msg) do
+        event = Event.wrap(msg)
+
+        store_in_dataset(event) do
+          catch_business_error(event, &block)
         end
       end
     end
@@ -30,15 +30,17 @@ module CycloneLariat
 
     attr_reader :errors_notifier, :message_notifier, :events_repo
 
-    def log_received_message(queue, body)
-      message_notifier&.info 'Receive message', queue: queue, aws_message_id: body[:MessageId], message: body[:Message]
+    def receive_message(body)
+      body[:Message] ? JSON.parse(body[:Message], symbolize_names: true ) : body
     end
 
     def store_in_dataset(event)
       return yield if events_repo.nil?
-      return true  if events_repo.exists?(uuid: event.uuid)
 
-      events_repo.create(event)
+      existed = events_repo.find(uuid: event.uuid)
+      return true if existed&.processed?
+
+      events_repo.create(event) unless existed
       yield
       events_repo.processed! uuid: event.uuid, error: event.client_error
     end
@@ -50,20 +52,11 @@ module CycloneLariat
       event.client_error = e
     end
 
-    def catch_standard_error(queue, body)
+    def catch_standard_error(queue, msg)
       yield
-    rescue StandardError => e
-      errors_notifier&.error(e, queue: queue, aws_message_id: body[:MessageId], message: body[:Message])
+    rescue Exception => e
+      errors_notifier&.error(e, queue: queue, message: msg)
       raise e
     end
-
-    def check(msg)
-      if msg.nil? || msg.empty?
-        errors_notifier&.error(Errors::EmptyMessage.new)
-        false
-      else
-        true
-      end
-    end
   end
 end

data/lib/cyclone_lariat/sns_client.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-sns'
+require_relative 'abstract/client'
+
+module CycloneLariat
+  class SnsClient < Abstract::Client
+    include LunaPark::Extensions::Injector
+
+    dependency(:aws_client_class) { Aws::SNS::Client }
+
+    SNS_SUFFIX = :fanout
+
+    def publish(msg, topic: nil)
+      topic ||= [instance, msg.kind, SNS_SUFFIX, publisher, msg.type].join('-')
+
+      aws_client.publish(
+        topic_arn: topic_arn(topic),
+        message: msg.to_json
+      )
+    end
+
+    def publish_event(type, data: {}, version: self.version, uuid: SecureRandom.uuid, topic: nil)
+      publish event(type, data: data, version: version, uuid: uuid), topic: topic
+    end
+
+    def publish_command(type, data: {}, version: self.version, uuid: SecureRandom.uuid, topic: nil)
+      publish command(type, data: data, version: version, uuid: uuid), topic: topic
+    end
+
+    private
+
+    def topic_arn(topic_name)
+      list  = aws_client.list_topics.topics
+      topic = list.find { |t| t.topic_arn.match?(topic_name) }
+      raise Errors::TopicNotFound.new(expected_topic: topic_name, existed_topics: list.map(&:topic_arn)) if topic.nil?
+
+      topic.topic_arn
+    end
+  end
+end

data/lib/cyclone_lariat/sqs_client.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-sqs'
+require_relative 'abstract/client'
+
+module CycloneLariat
+  class SqsClient < Abstract::Client
+    include LunaPark::Extensions::Injector
+
+    dependency(:aws_client_class) { Aws::SQS::Client }
+
+    SQS_SUFFIX = :queue
+
+    def publish(msg, dest: nil, topic: nil)
+      raise ArgumentError, 'You should define dest or topic' if dest.nil? && topic.nil?
+
+      topic ||= [instance, msg.kind, SQS_SUFFIX, publisher, msg.type, dest].join('-')
+
+      aws_client.send_message(
+        queue_url: url(topic),
+        message_body: msg.to_json
+      )
+    end
+
+    def publish_event(type, dest: nil, data: {}, version: self.version, uuid: SecureRandom.uuid, topic: nil)
+      publish event(type, data: data, version: version, uuid: uuid), dest: dest, topic: topic
+    end
+
+    def publish_command(type, dest: nil, data: {}, version: self.version, uuid: SecureRandom.uuid, topic: nil)
+      publish command(type, data: data, version: version, uuid: uuid), dest: dest, topic: topic
+    end
+
+    private
+
+    def url(topic_name)
+      aws_client.get_queue_url(queue_name: topic_name).queue_url
+    rescue Aws::SQS::Errors::NonExistentQueue => _e
+      raise Errors::TopicNotFound.new(expected_topic: topic_name, existed_topics: aws_client.list_queues)
+    end
+  end
+end

data/lib/cyclone_lariat/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CycloneLariat
-  VERSION = '0.2.3'
+  VERSION = '0.3.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cyclone_lariat
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.3
 platform: ruby
 authors:
 - Alexander Kudrin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-09 00:00:00.000000000 Z
+date: 2021-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-sns
@@ -25,6 +25,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-sqs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: luna_park
   requirement: !ruby/object:Gem::Requirement
@@ -260,11 +274,15 @@ files:
 - docs/_imgs/diagram.png
 - docs/_imgs/lariat.jpg
 - lib/cyclone_lariat.rb
-- lib/cyclone_lariat/client.rb
+- lib/cyclone_lariat/abstract/client.rb
+- lib/cyclone_lariat/abstract/message.rb
+- lib/cyclone_lariat/command.rb
 - lib/cyclone_lariat/errors.rb
 - lib/cyclone_lariat/event.rb
-- lib/cyclone_lariat/events_repo.rb
+- lib/cyclone_lariat/messages_repo.rb
 - lib/cyclone_lariat/middleware.rb
+- lib/cyclone_lariat/sns_client.rb
+- lib/cyclone_lariat/sqs_client.rb
 - lib/cyclone_lariat/version.rb
 - lib/tasks/db.rake
 homepage: https://am-team.github.io/cyclone_lariat/#/

data/lib/cyclone_lariat/client.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require 'aws-sdk-sns'
-require 'luna_park/extensions/injector'
-require_relative 'event'
-require_relative 'errors'
-
-module CycloneLariat
-  class Client
-    include LunaPark::Extensions::Injector
-
-    dependency(:aws_sns_client_class)  { Aws::SNS::Client }
-    dependency(:aws_credentials_class) { Aws::Credentials }
-
-    DEFAULT_VERSION  = 1
-    DEFAULT_INSTANCE = :prod
-    SNS_SUFFIX       = :fanout
-
-    def initialize(key:, secret_key:, region:, version: nil, publisher: nil, instance: nil)
-      @key = key
-      @secret_key = secret_key
-      @region = region
-      @version = version
-      @publisher = publisher
-      @instance = instance
-    end
-
-    def event(type, data: {}, version: self.version, uuid: SecureRandom.uuid)
-      Event.wrap(
-        uuid: uuid,
-        type: type,
-        sent_at: Time.now.iso8601,
-        version: version,
-        publisher: publisher,
-        data: data
-      )
-    end
-
-    def publish(msg, to: nil)
-      topic = to || [instance, msg.kind, SNS_SUFFIX, publisher, msg.type].join('-')
-
-      aws_client.publish(
-        topic_arn: topic_arn(topic),
-        message: msg.to_json
-      )
-    end
-
-    def publish_event(type, data: {}, version: self.version, uuid: SecureRandom.uuid, to: nil)
-      publish event(type, data: data, version: version, uuid: uuid), to: to
-    end
-
-    class << self
-      def version(version = nil)
-        version.nil? ? @version || DEFAULT_VERSION : @version = version
-      end
-
-      def instance(instance = nil)
-        instance.nil? ? @instance || DEFAULT_INSTANCE : @instance = instance
-      end
-
-      def publisher(publisher = nil)
-        publisher.nil? ? @publisher || (raise 'You should define publisher') : @publisher = publisher
-      end
-    end
-
-    def version
-      @version ||= self.class.version
-    end
-
-    def publisher
-      @publisher ||= self.class.publisher
-    end
-
-    def instance
-      @instance ||= self.class.instance
-    end
-
-    private
-
-    attr_reader :key, :secret_key, :region
-
-    def topic_arn(topic_name)
-      list  = aws_client.list_topics.topics
-      topic = list.find { |t| t.topic_arn.match?(topic_name) }
-      raise Errors::TopicNotFound.new(expected_topic: topic_name, existed_topics: list.map(&:topic_arn)) if topic.nil?
-
-      topic.topic_arn
-    end
-
-    def aws_client
-      @aws_client ||= aws_sns_client_class.new(credentials: aws_credentials, region: region)
-    end
-
-    def aws_credentials
-      @aws_credentials ||= aws_credentials_class.new(key, secret_key)
-    end
-  end
-end

data/lib/cyclone_lariat/events_repo.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'event'
-
-module CycloneLariat
-  class EventsRepo
-    attr_reader :dataset
-
-    def initialize(dataset)
-      @dataset = dataset
-    end
-
-    def create(event)
-      dataset.insert(
-        uuid: event.uuid,
-        type: event.type,
-        publisher: event.publisher,
-        data: JSON.generate(event.data),
-        client_error_message: event.client_error&.message,
-        client_error_details: JSON.generate(event.client_error&.details),
-        version: event.version,
-        sent_at: event.sent_at
-      )
-    end
-
-    def exists?(uuid:)
-      dataset.where(uuid: uuid).limit(1).any?
-    end
-
-    def processed!(uuid:, error: nil)
-      data = { processed_at: Sequel.function(:NOW) }
-      data.merge!(
-        client_error_message: error&.message,
-        client_error_details: JSON.generate(error&.details),
-      ) if error
-
-      !dataset.where(uuid: uuid).update(data).zero?
-    end
-
-    def find(uuid:)
-      raw = dataset.where(uuid: uuid).first
-      raw[:data]                 = JSON.parse(raw[:data], symbolize_names: true)
-      raw[:client_error_details] = JSON.parse(raw[:client_error_details], symbolize_names: true) if raw[:client_error_details]
-      Event.wrap raw
-    end
-
-    def each_unprocessed
-      dataset.where(processed_at: nil).each do |raw|
-        raw[:data]                 = JSON.parse(raw[:data], symbolize_names: true)
-        raw[:client_error_details] = JSON.parse(raw[:client_error_details], symbolize_names: true) if raw[:client_error_details]
-        event = Event.wrap(raw)
-        yield(event)
-      end
-    end
-
-    def each_with_client_errors
-      dataset.where { (processed_at !~ nil) & (client_error_message !~ nil) }.each do |raw|
-        raw[:data]                 = JSON.parse(raw[:data], symbolize_names: true)
-        raw[:client_error_details] = JSON.parse(raw[:client_error_details], symbolize_names: true) if raw[:client_error_details]
-        event = Event.wrap(raw)
-        yield(event)
-      end
-    end
-  end
-end