pub_sub_model_sync 0.1.4 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4eda619ab984f99ffe46cfef36fa380aaa6766c1564081dcc4e5e53e6f7976e0
-  data.tar.gz: dd056d897c96bac38a20c115fee501cbb1383038483f74849bbb0e7217568163
+  metadata.gz: 3016ebc69eba9ccb8b168734db1b947b77a4c9400f48d8228f979a7c1ec9eab8
+  data.tar.gz: 82187606c0411ece3eb0d78db59a8794019e80acd5374ffd92b95b0eee4368f7
 SHA512:
-  metadata.gz: 75796a135c2f820d89303c29c9bb6dc78eaa1e207391a07ba86a45f547a7007b4b00f767bb949d354c5a90c504b5d2d287619fd3106bca1dce71e75588ac6173
-  data.tar.gz: fe4829f970142bfea0089beb4e86a27c9d1e08049213372ae77f94b9d02d16752218d58e88b25ac1f34848931da3651e4405caa3a8932401c1410d7f04e3d0da
+  metadata.gz: f4335695f26d69f091a2ea1726221aab4b07b712827318adfe16f2d1275cde21a0860ce7562ed266f6a0661eb2b8d634abea0956a4478ad55f70e6c199c8a364
+  data.tar.gz: 9252e45ab27b332d9b50afc93da62a0a039c707a1bb3b219ff4e60c1c4f3dae8eb7a85024fc3d1dab87c006e448e60cf3d1f3d953dad8cc8fced24bd375b47cd

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Change Log
 
+# 0.2.3 (April 15, 2020)
+- Improve helper names
+- feat: perform manual sync with custom settings
+- fix for "IO timeout when reading 7 bytes" error (Rabbit)
+- style: do not print processed message when failed
+- feat: retry delivery message when failed (RabbitMQ)
+
+
+# 0.2.2 (March 27, 2020)
+- fix default value for cattr_accessor in ror < 5.2
+- add callbacks when publishing a message
+
+# 0.2.1
+- Add on demand model sync method
+
+# 0.2.0
+- Add apache kafka support
+- Add Service interface for future references
+- Improve Services to use a single/common message performer
+
 # 0.1.4
 - Add attribute aliases when publishing, ```ps_publish(['name:full_name', 'email'])```
 - Ability to retrieve publisher/subscriber crud settings

data/Gemfile

@@ -3,6 +3,7 @@ source "https://rubygems.org"
 gem 'rubocop'
 gem 'bunny' # rabbit-mq
 gem 'google-cloud-pubsub' # google pub/sub
+gem 'ruby-kafka' # kafka pub/sub
 
 # Specify your gem's dependencies in pub_sub_model_sync.gemspec
 gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pub_sub_model_sync (0.1.4)
+    pub_sub_model_sync (0.2.3)
       activesupport
       rails
 
@@ -60,6 +60,7 @@ GEM
     concurrent-ruby (1.1.6)
     crass (1.0.6)
     diff-lcs (1.3)
+    digest-crc (0.5.1)
     erubi (1.9.0)
     faraday (0.17.3)
       multipart-post (>= 1.2, < 3)
@@ -81,7 +82,7 @@ GEM
       googleauth (>= 0.6.2, < 0.10.0)
       grpc (>= 1.7.2, < 2.0)
       rly (~> 0.2.3)
-    google-protobuf (3.11.4-universal-darwin)
+    google-protobuf (3.11.4)
     googleapis-common-protos (1.3.9)
       google-protobuf (~> 3.0)
       googleapis-common-protos-types (~> 1.0)
@@ -95,7 +96,7 @@ GEM
       multi_json (~> 1.11)
       os (>= 0.9, < 2.0)
       signet (~> 0.7)
-    grpc (1.27.0-universal-darwin)
+    grpc (1.27.0)
       google-protobuf (~> 3.11)
       googleapis-common-protos-types (~> 1.0)
     grpc-google-iam-v1 (0.6.9)
@@ -180,6 +181,8 @@ GEM
       rexml
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 1.7)
+    ruby-kafka (1.0.0)
+      digest-crc
     ruby-progressbar (1.10.1)
     signet (0.11.0)
       addressable (~> 2.3)
@@ -214,6 +217,7 @@ DEPENDENCIES
   rake
   rspec
   rubocop
+  ruby-kafka
   sqlite3
 
 BUNDLED WITH

data/README.md

@@ -1,5 +1,5 @@
 # PubSubModelSync
-Permit to sync models data and make calls between rails apps using google or rabbitmq pub/sub service. 
+Permit to sync models data and make calls between rails apps using google or rabbitmq or apache kafka pub/sub service. 
 
 Note: This gem is based on [MultipleMan](https://github.com/influitive/multiple_man) which for now looks unmaintained.
 
@@ -14,8 +14,10 @@ Note: This gem is based on [MultipleMan](https://github.com/influitive/multiple_
 Add this line to your application's Gemfile:
 ```ruby
 gem 'pub_sub_model_sync'
+
 gem 'google-cloud-pubsub' # to use google pub/sub service
 gem 'bunny' # to use rabbit-mq pub/sub service
+gem 'ruby-kafka' # to use apache kafka pub/sub service
 ```
 And then execute: $ bundle install
 
@@ -43,6 +45,14 @@ And then execute: $ bundle install
     ```
     See details here: https://github.com/ruby-amqp/bunny
 
+- configuration for Apache Kafka (You need kafka installed)
+    ```ruby
+    PubSubModelSync::Config.service_name = :kafka
+    PubSubModelSync::Config.kafka_connection = [["kafka1:9092", "localhost:2121"], logger: Rails.logger]
+    PubSubModelSync::Config.topic_name = 'sample-topic'
+    ```
+    See details here: https://github.com/zendesk/ruby-kafka    
+
 - Add publishers/subscribers to your models (See examples below)
 
 - Start subscribers to listen for publishers (Only in the app that has subscribers)
@@ -73,7 +83,10 @@ end
 
 # Samples
 User.create(name: 'test user', email: 'sample@gmail.com') # Review your App 2 to see the created user (only name will be saved)
+User.new(name: 'test user').ps_perform_sync(:create) # similar to above to perform sync on demand
+
 User.ps_class_publish({ msg: 'Hello' }, action: :greeting) # User.greeting method (Class method) will be called in App2
+PubSubModelSync::Publisher.new.publish_data(User, { msg: 'Hello' }, :greeting) # similar to above when not included publisher concern
 ```
 
 ## Advanced Example
@@ -84,9 +97,13 @@ class User < ActiveRecord::Base
   include PubSubModelSync::PublisherConcern
   ps_publish(%i[name:full_name email], actions: %i[update], as_klass: 'Client', id: :client_id)
   
-  def ps_skip_for?(_action)
+  def ps_skip_callback?(_action)
     false # here logic with action to skip push message
   end
+  
+  def ps_skip_sync?(_action)
+      false # here logic with action to skip push message
+    end
 end
 
 # App 2 (Subscriber)
@@ -102,6 +119,61 @@ class User < ActiveRecord::Base
 end
 ```
 
+Note: Be careful with collision of names
+```
+class User
+    # ps_publish %i[name_data:name name:key] # key will be replaced with name_data 
+    ps_publish %i[name_data:name key_data:key] # use alias to avoid collision
+    
+    def key_data
+      name
+    end
+end
+``` 
+
+## API
+- Permit to cancel sync called after create/update/destroy (Before initializing sync service)
+  ```model.ps_skip_callback?(action)```    
+  Note: Return true to cancel sync
+  
+- Callback called before preparing data for sync (Permit to stop sync)
+  ```model.ps_skip_sync?(action)```     
+  Note: return true to cancel sync
+  
+- Callback called before sync (After preparing data)
+  ```model.ps_before_sync(action, data_to_deliver)```  
+  Note: If the method returns ```:cancel```, the sync will be stopped (message will not be published)
+
+- Callback called after sync
+  ```model.ps_after_sync(action, data_delivered)```  
+
+- Perform sync on demand (:create, :update, :destroy):   
+  The target model will receive a notification to perform the indicated action  
+  ```my_model.ps_perform_sync(action_name, custom_settings = {})```  
+  * custom_settings: override default settings defined for action_name ({ attrs: [], as_klass: nil, id: nil })
+    
+- Class level notification:     
+  ```User.ps_class_publish(data, action: action_name, as_klass: custom_klass_name)```
+  Target class ```User.action_name``` will be called when message is received    
+  * data: (required, :hash) message value to deliver    
+  * action_name: (required, :sim) same action name as defined in ps_class_subscribe(...)    
+  * as_klass: (optional, :string) same class name as defined in ps_class_subscribe(...)
+      
+- Class level notification (Same as above: on demand call)    
+  ```PubSubModelSync::Publisher.new.publish_data(Klass_name, data, action_name)```  
+  * klass_name: (required, Class) same class name as defined in ps_class_subscribe(...)
+  * data: (required, :hash) message value to deliver    
+  * action_name: (required, :sim) same action name as defined in ps_class_subscribe(...)
+  
+- Get crud subscription configured for the class   
+  ```User.ps_subscriber(action_name)```  
+  * action_name (default :create, :sym): can be :create, :update, :destroy
+- Get crud publisher configured for the class   
+  ```User.ps_publisher(action_name)```  
+  * action_name (default :create, :sym): can be :create, :update, :destroy
+- Inspect all configured listeners
+  ```PubSubModelSync::Config.listeners```
+  
 ## Testing with RSpec
 - Config: (spec/rails_helper.rb)
     ```ruby
@@ -109,15 +181,22 @@ end
       # when using google service
       require 'pub_sub_model_sync/mock_google_service'
       config.before(:each) do
-        pub_sub_mock = PubSubModelSync::MockGoogleService.new
-        allow(Google::Cloud::Pubsub).to receive(:new).and_return(pub_sub_mock)
+        google_mock = PubSubModelSync::MockGoogleService.new
+        allow(Google::Cloud::Pubsub).to receive(:new).and_return(google_mock)
       end
       
       # when using rabbitmq service
       require 'pub_sub_model_sync/mock_rabbit_service' 
       config.before(:each) do
-        bunny_mock = PubSubModelSync::MockRabbitService.new
-        allow(Bunny).to receive(:new).and_return(bunny_mock)
+        rabbit_mock = PubSubModelSync::MockRabbitService.new
+        allow(Bunny).to receive(:new).and_return(rabbit_mock)
+      end
+    
+      # when using apache kafka service
+      require 'pub_sub_model_sync/mock_kafka_service' 
+      config.before(:each) do
+        kafka_mock = PubSubModelSync::MockKafkaService.new
+        allow(Kafka).to receive(:new).and_return(kafka_mock)
       end
   
     ```
@@ -160,15 +239,6 @@ end
       expect_any_instance_of(publisher).to receive(:publish_data).with('User', data, action)
     end
     ```
-    
-    There are two special methods to extract crud configuration settings (attrs, id, ...):
-    
-    Subscribers: ```User.ps_subscriber```
-    
-    Publishers: ```User.ps_publisher```
-    
-    Note: Inspect all configured listeners with: 
-    ``` PubSubModelSync::Config.listeners ```
 
 ## Contributing
 

data/lib/pub_sub_model_sync.rb

@@ -11,8 +11,11 @@ require 'pub_sub_model_sync/publisher_concern'
 require 'pub_sub_model_sync/runner'
 require 'pub_sub_model_sync/connector'
 require 'pub_sub_model_sync/message_processor'
+
+require 'pub_sub_model_sync/service_base'
 require 'pub_sub_model_sync/service_google'
 require 'pub_sub_model_sync/service_rabbit'
+require 'pub_sub_model_sync/service_kafka'
 
 module PubSubModelSync
   class Error < StandardError; end

data/lib/pub_sub_model_sync/config.rb

@@ -2,9 +2,9 @@
 
 module PubSubModelSync
   class Config
-    cattr_accessor :listeners, default: []
-    cattr_accessor :publishers, default: []
-    cattr_accessor :service_name, default: :google
+    cattr_accessor(:listeners) { [] }
+    cattr_accessor(:publishers) { [] }
+    cattr_accessor(:service_name) { :google }
     cattr_accessor :logger
 
     # google service
@@ -13,6 +13,9 @@ module PubSubModelSync
     # rabbitmq service
     cattr_accessor :bunny_connection, :queue_name, :topic_name
 
+    # kafka service
+    cattr_accessor :kafka_connection, :topic_name
+
     def self.log(msg, kind = :info)
       msg = "PS_MSYNC ==> #{msg}"
       if logger == :raise_error

data/lib/pub_sub_model_sync/connector.rb

@@ -16,6 +16,8 @@ module PubSubModelSync
       case Config.service_name
       when :google
         PubSubModelSync::ServiceGoogle.new
+      when :kafka
+        PubSubModelSync::ServiceKafka.new
       else # :rabbit_mq
         PubSubModelSync::ServiceRabbit.new
       end

data/lib/pub_sub_model_sync/message_processor.rb

@@ -13,10 +13,13 @@ module PubSubModelSync
     end
 
     def process
+      @failed = false
       log 'processing message'
       listeners = filter_listeners
-      eval_message(listeners) if listeners.any?
-      log 'processed message'
+      return log 'Skipped: No listeners' unless listeners.any?
+
+      eval_message(listeners)
+      log 'processed message' unless @failed
     end
 
     private
@@ -36,6 +39,7 @@ module PubSubModelSync
       model_class.send(listener[:action], data)
     rescue => e
       log("Error listener (#{listener}): #{e.message}", :error)
+      @failed = true
     end
 
     # support for: create, update, destroy
@@ -49,13 +53,13 @@ module PubSubModelSync
       end
     rescue => e
       log("Error listener (#{listener}): #{e.message}", :error)
+      @failed = true
     end
 
     def find_model(listener)
       model_class = listener[:klass].constantize
       identifier = listener[:settings][:id] || :id
-      model_class.where(identifier => attrs[:id]).first ||
-        model_class.new(identifier => attrs[:id])
+      model_class.where(identifier => attrs[:id]).first_or_initialize
     end
 
     def populate_model(model, listener)

data/lib/pub_sub_model_sync/mock_kafka_service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  class MockKafkaService
+    class MockProducer
+      def produce(*_args)
+        true
+      end
+
+      def deliver_messages(*_args)
+        true
+      end
+
+      def shutdown
+        true
+      end
+    end
+
+    class MockConsumer
+      def each_message(*_args)
+        true
+      end
+
+      def stop(*_args)
+        true
+      end
+
+      def subscribe(*_args)
+        true
+      end
+    end
+
+    def producer(*_args)
+      MockProducer.new
+    end
+
+    def consumer(*_args)
+      MockConsumer.new
+    end
+
+    def close
+      true
+    end
+  end
+end

data/lib/pub_sub_model_sync/mock_rabbit_service.rb

@@ -30,6 +30,10 @@ module PubSubModelSync
       def topic(*_args)
         @topic ||= MockTopic.new
       end
+
+      def close
+        true
+      end
     end
 
     def create_channel(*_args)

data/lib/pub_sub_model_sync/publisher.rb

@@ -14,19 +14,24 @@ module PubSubModelSync
 
     # @param settings (Hash): { attrs: [], as_klass: nil, id: nil }
     def publish_model(model, action, settings = nil)
+      return if model.ps_skip_sync?(action)
+
       settings ||= model.class.ps_publisher_info(action)
       attributes = build_model_attrs(model, action, settings)
       data = {}
       data = build_model_data(model, settings[:attrs]) if action != :destroy
+      res_before = model.ps_before_sync(action, data)
+      return if res_before == :cancel
+
       connector.publish(data.symbolize_keys, attributes)
+      model.ps_after_sync(action, data)
     end
 
     def self.build_attrs(klass, action, id = nil)
       {
         klass: klass.to_s,
         action: action.to_sym,
-        id: id,
-        service_model_sync: true
+        id: id
       }
     end
 

data/lib/pub_sub_model_sync/publisher_concern.rb

@@ -6,11 +6,30 @@ module PubSubModelSync
       base.extend(ClassMethods)
     end
 
-    # Permit to skip a publish callback
-    def ps_skip_for?(_action)
+    # Before initializing sync service (callbacks: after create/update/destroy)
+    def ps_skip_callback?(_action)
       false
     end
 
+    # before preparing data to sync
+    def ps_skip_sync?(_action)
+      false
+    end
+
+    # before delivering data
+    def ps_before_sync(_action, _data); end
+
+    # after delivering data
+    def ps_after_sync(_action, _data); end
+
+    # To perform sync on demand
+    # @param custom_settings (Hash): { attrs: [], as_klass: nil, id: nil }
+    def ps_perform_sync(action = :create, custom_settings = {})
+      service = self.class.ps_publisher_service
+      model_settings = self.class.ps_publisher_info(action) || {}
+      service.publish_model(self, action, model_settings.merge(custom_settings))
+    end
+
     module ClassMethods
       # Permit to publish crud actions (:create, :update, :destroy)
       # @param settings (Hash): { actions: nil, as_klass: nil, id: nil }
@@ -23,12 +42,14 @@ module PubSubModelSync
         end
       end
 
+      # Publisher info for specific action
       def ps_publisher_info(action = :create)
         PubSubModelSync::Config.publishers.select do |listener|
           listener[:klass] == name && listener[:action] == action
         end.last
       end
 
+      # On demand class level publisher
       def ps_class_publish(data, action:, as_klass: nil)
         as_klass = (as_klass || name).to_s
         ps_publisher_service.publish_data(as_klass, data, action.to_sym)
@@ -42,7 +63,7 @@ module PubSubModelSync
 
       def ps_register_callback(action, info)
         after_commit(on: action) do |model|
-          unless model.ps_skip_for?(action)
+          unless model.ps_skip_callback?(action)
             service = model.class.ps_publisher_service
             service.publish_model(model, action.to_sym, info)
           end

data/lib/pub_sub_model_sync/service_base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  class ServiceBase
+    SERVICE_KEY = 'service_model_sync'
+
+    def listen_messages
+      raise 'method :listen_messages must be defined in service'
+    end
+
+    def publish(_data, _attributes)
+      raise 'method :publish must be defined in service'
+    end
+
+    def stop
+      raise 'method :stop must be defined in service'
+    end
+
+    private
+
+    # @param payload (String JSON): '{"data":{},"attributes":{..}}'
+    #   refer: PubSubModelSync::Publisher (.publish_model | .publish_data)
+    def perform_message(payload)
+      data, attrs = parse_message_payload(payload)
+      args = [data, attrs[:klass], attrs[:action], attrs]
+      PubSubModelSync::MessageProcessor.new(*args).process
+    end
+
+    def parse_message_payload(payload)
+      message_payload = JSON.parse(payload).symbolize_keys
+      data = message_payload[:data].symbolize_keys
+      attrs = message_payload[:attributes].symbolize_keys
+      [data, attrs]
+    end
+  end
+end

data/lib/pub_sub_model_sync/service_google.rb

@@ -6,7 +6,7 @@ rescue LoadError # rubocop:disable Lint/SuppressedException
 end
 
 module PubSubModelSync
-  class ServiceGoogle
+  class ServiceGoogle < ServiceBase
     attr_accessor :service, :topic, :subscription, :config, :subscriber
 
     def initialize
@@ -30,7 +30,9 @@ module PubSubModelSync
 
     def publish(data, attributes)
       log("Publishing message: #{[data, attributes]}")
-      topic.publish(data.to_json, attributes)
+
+      payload = { data: data, attributes: attributes }.to_json
+      topic.publish(payload, { SERVICE_KEY => true })
     end
 
     def stop
@@ -47,12 +49,9 @@ module PubSubModelSync
 
     def process_message(received_message)
       message = received_message.message
-      attrs = message.attributes.symbolize_keys
-      return unless attrs[:service_model_sync]
+      return unless message.attributes[SERVICE_KEY]
 
-      data = JSON.parse(message.data).symbolize_keys
-      args = [data, attrs[:klass], attrs[:action], attrs]
-      PubSubModelSync::MessageProcessor.new(*args).process
+      perform_message(message.data)
     rescue => e
       log("Error processing message: #{[received_message, e.message]}", :error)
     ensure

data/lib/pub_sub_model_sync/service_kafka.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+begin
+  require 'kafka'
+rescue LoadError # rubocop:disable Lint/SuppressedException
+end
+
+module PubSubModelSync
+  class ServiceKafka < ServiceBase
+    cattr_accessor :producer
+
+    attr_accessor :service, :consumer
+    attr_accessor :config
+    CONSUMER_GROUP = 'service_model_sync'
+
+    def initialize
+      @config = PubSubModelSync::Config
+      @service = Kafka.new(*config.kafka_connection)
+    end
+
+    def listen_messages
+      log('Listener starting...')
+      start_consumer
+      consumer.each_message(&method(:process_message))
+    rescue PubSubModelSync::Runner::ShutDown
+      raise
+    rescue => e
+      log("Error listening message: #{[e.message, e.backtrace]}", :error)
+    end
+
+    def publish(data, attributes)
+      log("Publishing: #{[data, attributes]}")
+      payload = { data: data, attributes: attributes }
+      producer.produce(payload.to_json, message_settings)
+      producer.deliver_messages
+    rescue => e
+      info = [data, attributes, e.message, e.backtrace]
+      log("Error publishing: #{info}", :error)
+    end
+
+    def stop
+      log('Listener stopping...')
+      consumer.stop
+    end
+
+    private
+
+    def message_settings
+      { topic: config.topic_name, headers: { SERVICE_KEY => true } }
+    end
+
+    def start_consumer
+      @consumer = service.consumer(group_id: CONSUMER_GROUP)
+      consumer.subscribe(config.topic_name)
+    end
+
+    def producer
+      return self.class.producer if self.class.producer
+
+      at_exit { self.class.producer.shutdown }
+      self.class.producer = service.producer
+    end
+
+    def process_message(message)
+      return unless message.headers[SERVICE_KEY]
+
+      perform_message(message.value)
+    rescue => e
+      error = [message, e.message, e.backtrace]
+      log("Error processing message: #{error}", :error)
+    end
+
+    def log(msg, kind = :info)
+      config.log("Kafka Service ==> #{msg}", kind)
+    end
+  end
+end

data/lib/pub_sub_model_sync/service_rabbit.rb

@@ -6,10 +6,9 @@ rescue LoadError # rubocop:disable Lint/SuppressedException
 end
 
 module PubSubModelSync
-  class ServiceRabbit
+  class ServiceRabbit < ServiceBase
     attr_accessor :service, :channel, :queue, :topic
     attr_accessor :config
-    SERVICE_KEY = 'service_model_sync'
 
     def initialize
       @config = PubSubModelSync::Config
@@ -29,9 +28,12 @@ module PubSubModelSync
 
     def publish(data, attributes)
       log("Publishing: #{[data, attributes]}")
-      subscribe_to_queue
-      payload = { data: data, attributes: attributes }
-      topic.publish(payload.to_json, routing_key: queue.name, type: SERVICE_KEY)
+      deliver_data(data, attributes)
+    # TODO: max retry
+    rescue Timeout::Error => e
+      log("Error publishing (retrying....): #{e.message}", :error)
+      initialize
+      retry
     rescue => e
       info = [data, attributes, e.message, e.backtrace]
       log("Error publishing: #{info}", :error)
@@ -44,24 +46,19 @@ module PubSubModelSync
 
     private
 
+    def message_settings
+      { routing_key: queue.name, type: SERVICE_KEY }
+    end
+
     def process_message(_delivery_info, meta_info, payload)
       return unless meta_info[:type] == SERVICE_KEY
 
-      data, attrs = parse_message_payload(payload)
-      args = [data, attrs[:klass], attrs[:action], attrs]
-      PubSubModelSync::MessageProcessor.new(*args).process
+      perform_message(payload)
     rescue => e
       error = [payload, e.message, e.backtrace]
       log("Error processing message: #{error}", :error)
     end
 
-    def parse_message_payload(payload)
-      message_payload = JSON.parse(payload).symbolize_keys
-      data = message_payload[:data].symbolize_keys
-      attrs = message_payload[:attributes].symbolize_keys
-      [data, attrs]
-    end
-
     def subscribe_to_queue
       service.start
       @channel = service.create_channel
@@ -78,5 +75,16 @@ module PubSubModelSync
     def log(msg, kind = :info)
       config.log("Rabbit Service ==> #{msg}", kind)
     end
+
+    def deliver_data(data, attributes)
+      subscribe_to_queue
+      payload = { data: data, attributes: attributes }
+      topic.publish(payload.to_json, message_settings)
+
+      # Ugly fix: "IO timeout when reading 7 bytes"
+      # https://stackoverflow.com/questions/39039129/rabbitmq-timeouterror-io-timeout-when-reading-7-bytes
+      channel.close
+      service.close
+    end
   end
 end

data/lib/pub_sub_model_sync/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pub_sub_model_sync
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.3
 platform: ruby
 authors:
 - Owen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-25 00:00:00.000000000 Z
+date: 2020-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -119,12 +119,15 @@ files:
 - lib/pub_sub_model_sync/connector.rb
 - lib/pub_sub_model_sync/message_processor.rb
 - lib/pub_sub_model_sync/mock_google_service.rb
+- lib/pub_sub_model_sync/mock_kafka_service.rb
 - lib/pub_sub_model_sync/mock_rabbit_service.rb
 - lib/pub_sub_model_sync/publisher.rb
 - lib/pub_sub_model_sync/publisher_concern.rb
 - lib/pub_sub_model_sync/railtie.rb
 - lib/pub_sub_model_sync/runner.rb
+- lib/pub_sub_model_sync/service_base.rb
 - lib/pub_sub_model_sync/service_google.rb
+- lib/pub_sub_model_sync/service_kafka.rb
 - lib/pub_sub_model_sync/service_rabbit.rb
 - lib/pub_sub_model_sync/subscriber_concern.rb
 - lib/pub_sub_model_sync/tasks/worker.rake