pub_sub_model_sync 0.1.2

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'pub_sub_model_sync'
+
+# 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/pub_sub_model_sync.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'pub_sub_model_sync/version'
+require 'active_support'
+
+require 'pub_sub_model_sync/railtie'
+require 'pub_sub_model_sync/config'
+require 'pub_sub_model_sync/subscriber_concern'
+require 'pub_sub_model_sync/publisher'
+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_google'
+require 'pub_sub_model_sync/service_rabbit'
+
+module PubSubModelSync
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/pub_sub_model_sync/config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  class Config
+    cattr_accessor :listeners, default: []
+    cattr_accessor :service_name, default: :google
+    cattr_accessor :logger
+
+    # google service
+    cattr_accessor :project, :credentials, :topic_name, :subscription_name
+
+    # rabbitmq service
+    cattr_accessor :bunny_connection, :queue_name, :topic_name
+
+    def self.log(msg, kind = :info)
+      msg = "PS_MSYNC ==> #{msg}"
+      logger ? logger.send(kind, msg) : puts(msg)
+    end
+  end
+end

data/lib/pub_sub_model_sync/connector.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'google/cloud/pubsub'
+module PubSubModelSync
+  class Connector
+    attr_accessor :service
+    delegate :listen_messages, :publish, :stop, to: :service
+
+    def initialize
+      @service = build_service
+    end
+
+    private
+
+    def build_service
+      case Config.service_name
+      when :google
+        PubSubModelSync::ServiceGoogle.new
+      else # :rabbit_mq
+        PubSubModelSync::ServiceRabbit.new
+      end
+    end
+  end
+end

data/lib/pub_sub_model_sync/message_processor.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  class MessageProcessor
+    attr_accessor :data, :attrs, :settings
+
+    # @param data (Hash): any hash value to deliver
+    # @param settings (optional): { id: id_val }
+    def initialize(data, klass, action, settings = {})
+      @data = data
+      @settings = settings
+      @attrs = settings.merge(klass: klass, action: action)
+    end
+
+    def process
+      log 'processing message'
+      listeners = filter_listeners
+      eval_message(listeners) if listeners.any?
+      log 'processed message'
+    end
+
+    private
+
+    def eval_message(listeners)
+      listeners.each do |listener|
+        if listener[:direct_mode]
+          call_class_listener(listener)
+        else
+          call_listener(listener)
+        end
+      end
+    end
+
+    def call_class_listener(listener)
+      model_class = listener[:klass].constantize
+      model_class.send(listener[:action], data)
+    rescue => e
+      log("Error listener (#{listener}): #{e.message}", :error)
+    end
+
+    # support for: create, update, destroy
+    def call_listener(listener)
+      listener_add_crud_settings(listener)
+      model = find_model(listener)
+      if attrs[:action].to_sym == :destroy
+        model.destroy!
+      else
+        populate_model(model, listener)
+        model.save!
+      end
+    rescue => e
+      log("Error listener (#{listener}): #{e.message}", :error)
+    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])
+    end
+
+    def populate_model(model, listener)
+      values = data.slice(*listener[:settings][:attrs])
+      values.each do |attr, value|
+        model.send("#{attr}=", value)
+      end
+    end
+
+    def filter_listeners
+      listeners = PubSubModelSync::Config.listeners
+      listeners.select do |listener|
+        listener[:as_klass].to_s == attrs[:klass].to_s &&
+          listener[:as_action].to_s == attrs[:action].to_s
+      end
+    end
+
+    def listener_add_crud_settings(listener)
+      model_class = listener[:klass].constantize
+      listener[:settings] = model_class.ps_msync_subscriber_settings
+    end
+
+    def log(message, kind = :info)
+      PubSubModelSync::Config.log "#{message} ==> #{[data, attrs]}", kind
+    end
+  end
+end

data/lib/pub_sub_model_sync/mock_google_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  class MockGoogleService
+    class MockStop
+      def wait!
+        true
+      end
+    end
+
+    class MockSubscriber
+      def start
+        true
+      end
+
+      def stop
+        @stop ||= MockStop.new
+      end
+      alias stop! stop
+    end
+
+    class MockSubscription
+      def listen(*_args)
+        @listen ||= MockSubscriber.new
+      end
+    end
+
+    class MockTopic
+      def subscription(*_args)
+        @subscription ||= MockSubscription.new
+      end
+      alias subscribe subscription
+
+      def publish(*_args)
+        true
+      end
+    end
+
+    def topic(*_args)
+      @topic ||= MockTopic.new
+    end
+    alias create_topic topic
+  end
+end

data/lib/pub_sub_model_sync/mock_rabbit_service.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  class MockRabbitService
+    class MockTopic
+      def publish(*_args)
+        true
+      end
+    end
+
+    class MockQueue
+      def bind(*_args)
+        true
+      end
+
+      def subscribe(*_args)
+        true
+      end
+
+      def name
+        'name'
+      end
+    end
+
+    class MockChannel
+      def queue(*_args)
+        @queue ||= MockQueue.new
+      end
+
+      def topic(*_args)
+        @topic ||= MockTopic.new
+      end
+    end
+
+    def create_channel(*_args)
+      @create_channel ||= MockChannel.new
+    end
+    alias channel create_channel
+
+    def start
+      true
+    end
+
+    def close
+      true
+    end
+  end
+end

data/lib/pub_sub_model_sync/publisher.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  class Publisher
+    attr_accessor :connector
+    def initialize
+      @connector = PubSubModelSync::Connector.new
+    end
+
+    def publish_data(klass, data, action)
+      attributes = self.class.build_attrs(klass, action)
+      connector.publish(data, attributes)
+    end
+
+    # @param settings (Hash): { attrs: [], as_klass: nil, id: nil }
+    def publish_model(model, action, settings = nil)
+      settings ||= model.class.ps_msync_publisher_settings
+      attributes = build_model_attrs(model, action, settings)
+      data = {}
+      if action != 'destroy'
+        data = model.as_json(only: settings[:attrs], methods: settings[:attrs])
+      end
+      connector.publish(data.symbolize_keys, attributes)
+    end
+
+    def self.build_attrs(klass, action, id = nil)
+      {
+        klass: klass.to_s,
+        action: action.to_sym,
+        id: id,
+        service_model_sync: true
+      }
+    end
+
+    private
+
+    def build_model_attrs(model, action, settings)
+      as_klass = (settings[:as_klass] || model.class.name).to_s
+      id_val = model.send(settings[:id] || :id)
+      self.class.build_attrs(as_klass, action, id_val)
+    end
+
+    def log(msg)
+      PubSubModelSync::Config.log(msg)
+    end
+  end
+end

data/lib/pub_sub_model_sync/publisher_concern.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  module PublisherConcern
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Permit to skip a publish callback
+    def ps_msync_skip_for?(_action)
+      false
+    end
+
+    module ClassMethods
+      # Permit to publish crud actions (:create, :update, :destroy)
+      # @param settings (Hash): { actions: nil, as_klass: nil, id: nil }
+      def ps_msync_publish(attrs, settings = {})
+        actions = settings.delete(:actions) || %i[create update destroy]
+        @ps_msync_publisher_settings = settings.merge(attrs: attrs)
+        ps_msync_register_callbacks(actions)
+      end
+
+      def ps_msync_publisher_settings
+        @ps_msync_publisher_settings
+      end
+
+      def ps_msync_class_publish(data, action:, as_klass: nil)
+        as_klass = (as_klass || name).to_s
+        ps_msync_publisher.publish_data(as_klass, data, action.to_sym)
+      end
+
+      def ps_msync_publisher
+        PubSubModelSync::Publisher.new
+      end
+
+      private
+
+      def ps_msync_register_callbacks(actions)
+        actions.each do |action|
+          after_commit(on: action) do |model|
+            unless model.ps_msync_skip_for?(action)
+              publisher = model.class.ps_msync_publisher
+              publisher.publish_model(model, action.to_sym)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pub_sub_model_sync/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'pub_sub_model_sync'
+require 'rails'
+module PubSubModelSync
+  class Railtie < ::Rails::Railtie
+    railtie_name :pub_sub_model_sync
+
+    rake_tasks do
+      load 'pub_sub_model_sync/tasks/worker.rake'
+    end
+  end
+end

data/lib/pub_sub_model_sync/runner.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module'
+module PubSubModelSync
+  class Runner
+    class ShutDown < StandardError; end
+    attr_accessor :connector
+
+    def initialize
+      @connector = PubSubModelSync::Connector.new
+    end
+
+    def run
+      trap_signals!
+      preload_framework!
+      start_listeners
+    rescue ShutDown
+      connector.stop
+    end
+
+    private
+
+    def start_listeners
+      connector.listen_messages
+    end
+
+    def trap_signals!
+      handler = proc do |signal|
+        puts "received #{Signal.signame(signal)}"
+        raise ShutDown
+      end
+      %w[INT QUIT TERM].each { |signal| Signal.trap(signal, handler) }
+    end
+
+    def preload_framework!
+      Rails.application.try(:eager_load!) if defined?(Rails)
+      Zeitwerk::Loader.eager_load_all if defined?(Zeitwerk::Loader)
+    end
+  end
+end

data/lib/pub_sub_model_sync/service_google.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+begin
+  require 'google/cloud/pubsub'
+rescue LoadError # rubocop:disable Lint/SuppressedException
+end
+
+module PubSubModelSync
+  class ServiceGoogle
+    attr_accessor :service, :topic, :subscription, :config, :subscriber
+
+    def initialize
+      @config = PubSubModelSync::Config
+      @service = Google::Cloud::Pubsub.new(project: config.project,
+                                           credentials: config.credentials)
+      @topic = service.topic(config.topic_name) ||
+               service.create_topic(config.topic_name)
+    end
+
+    def listen_messages
+      @subscription = subscribe_to_topic
+      @subscriber = subscription.listen(&method(:process_message))
+      log('Listener starting...')
+      subscriber.start
+      log('Listener started')
+      sleep
+      subscriber.stop.wait!
+      log('Listener stopped')
+    end
+
+    def publish(data, attributes)
+      log("Publishing message: #{[data, attributes]}")
+      topic.publish(data.to_json, attributes)
+    end
+
+    def stop
+      log('Listener stopping...')
+      subscriber.stop!
+    end
+
+    private
+
+    def subscribe_to_topic
+      topic.subscription(config.subscription_name) ||
+        topic.subscribe(config.subscription_name)
+    end
+
+    def process_message(received_message)
+      message = received_message.message
+      attrs = message.attributes.symbolize_keys
+      return unless attrs[:service_model_sync]
+
+      data = JSON.parse(message.data).symbolize_keys
+      args = [data, attrs[:klass], attrs[:action], attrs]
+      PubSubModelSync::MessageProcessor.new(*args).process
+    rescue => e
+      log("Error processing message: #{[received_message, e.message]}")
+    ensure
+      received_message.acknowledge!
+    end
+
+    def log(msg)
+      config.log("Google Service ==> #{msg}")
+    end
+  end
+end