artery 1.1.0

data/lib/artery/check.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Artery
+  class Check
+    TIMEOUT = ENV.fetch('ARTERY_CHECK_TIMEOUT', '1').to_i
+    ESSENTIAL_SERVICES = ENV.fetch('ARTERY_CHECK_ESSENTIAL_SERVICES', '').split(',')
+
+    def initialize(**options)
+      @timeout = options.fetch(:timeout, TIMEOUT)
+    end
+
+    def execute(services = ESSENTIAL_SERVICES)
+      all_services = Artery.subscriptions.blank? ? [] : Artery.subscriptions.keys.map(&:service).uniq
+      services = all_services if services.blank?
+
+      if services.blank?
+        Artery.logger.warn 'No services privided, exiting...'
+        return
+      end
+
+      result = {}
+
+      services.each do |service|
+        Artery.request "#{service}.healthz.check", {}, timeout: @timeout do |on|
+          on.success { result[service] = { status: :ok } }
+          on.error { |e| result[service] = { status: :error, message: e } }
+        end
+      end
+
+      result
+    end
+
+    def self.run(services)
+      Artery.logger.push_tags('Check')
+      result = Artery::Check.new.execute services
+
+      errors = result.select { |_service, res| res[:status] == :error }
+      return if errors.blank?
+
+      Artery.logger.error "There were errors:\n\t#{errors.map do |service, result|
+        "#{service}: #{result[:message]}"
+      end.join("\n\t")}"
+      exit 1
+    ensure
+      Artery.logger.pop_tags
+    end
+  end
+end

data/lib/artery/config.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Artery
+  module Config
+    extend ActiveSupport::Concern
+
+    included do # rubocop:disable Metrics/BlockLength
+      class << self
+        attr_accessor :message_class, :subscription_info_class, :service_name, :backend_config, :request_timeout,
+                      :error_handler
+
+        # Ability to redefine message class (for example, for non-activerecord applications)
+        def message_class
+          @message_class || get_model_class(:Message)
+        end
+
+        def subscription_info_class
+          @subscription_info_class || get_model_class(:SubscriptionInfo)
+        end
+
+        def service_name
+          @service_name || raise('Artery service_name must be configured!')
+        end
+
+        def logger
+          @logger || (self.logger = defined?(Rails) ? Rails.logger : Logger.new($stdout))
+        end
+
+        def logger=(logger)
+          @logger = ActiveSupport::TaggedLogging.new(logger)
+          @logger.push_tags 'Artery'
+        end
+
+        def request_timeout
+          @request_timeout || ENV.fetch('ARTERY_REQUEST_TIMEOUT', '15').to_i
+        end
+
+        def error_handler
+          @error_handler || (defined?(Artery::SentryErrorHandler) ? Artery::SentryErrorHandler : Artery::ErrorHandler)
+        end
+
+        def backend_config
+          @backend_config ||= {
+            servers: ENV.fetch('ARTERY_SERVERS', '').split(','),
+            user: ENV.fetch('ARTERY_USER', nil),
+            password: ENV.fetch('ARTERY_PASSWORD', nil),
+            reconnect_timeout: ENV.fetch('ARTERY_RECONNECT_TIMEOUT', '1').to_i,
+            reconnect_attempts: ENV.fetch('ARTERY_RECONNECT_ATTEMPTS', '10').to_i
+          }
+        end
+
+        private
+
+        def get_model_class(model)
+          if defined?(::ActiveRecord)
+            ::Artery::ActiveRecord.const_get(model, false)
+          elsif defined?(::NoBrainer)
+            ::Artery::NoBrainer.const_get(model, false)
+          else
+            raise ArgumentError, 'No supported ORMs found'
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      def configure
+        yield(self)
+      end
+    end
+  end
+end

data/lib/artery/engine.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "artery/browser/app"
+
+module Artery
+  class Engine < ::Rails::Engine
+    isolate_namespace Artery
+
+    endpoint Artery::Browser::App.build
+
+    config.generators do |g|
+      g.test_framework      :rspec
+      g.fixture_replacement :factory_girl, dir: 'spec/factories'
+    end
+  end
+end

data/lib/artery/errors.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Artery
+  class Error < StandardError
+    attr_accessor :artery_context
+
+    def initialize(message = nil, **context)
+      super(message)
+
+      @original_exception = context.delete(:original_exception)
+      @artery_context = context
+
+      set_backtrace @original_exception ? @original_exception.backtrace : caller if backtrace.blank?
+    end
+  end
+
+  class RequestError < Error
+    attr_accessor :uri, :response
+
+    def initialize(uri, response, **context)
+      @uri = uri
+      @response = response || {}
+
+      super(nil, **context)
+    end
+
+    def message
+      response[:error]
+    end
+  end
+
+  class TimeoutError < Error; end
+
+  class FormatError < Error
+    attr_accessor :route, :msg
+
+    def initialize(route, msg, **context)
+      @route = route
+      @msg = msg
+
+      super(nil, **context)
+    end
+
+    def message
+      "Received message from #{route} in wrong format: #{msg}"
+    end
+  end
+
+  # ErrorHandler
+  class ErrorHandler
+    def self.handle(exception)
+      Artery.logger.error "#{exception.message}\n#{exception.backtrace.join("\n")}"
+    end
+  end
+
+  if defined?(Sentry)
+    class SentryErrorHandler < ErrorHandler
+      def self.handle(exception)
+        super
+
+        options = {
+          extra: {}
+        }
+        options[:extra][:artery] = exception.artery_context if exception.respond_to?(:artery_context)
+
+        Sentry.capture_exception(exception, **options)
+      end
+    end
+  end
+
+  module_function
+
+  def handle_error(exception)
+    Artery.error_handler.handle exception
+  end
+end

data/lib/artery/healthz_subscription.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Artery
+  class HealthzSubscription
+    def subscribe
+      healthz_route = "#{Artery.service_name}.healthz.check"
+      Artery.logger.debug "Subscribing on '#{healthz_route}'"
+
+      Artery.subscribe healthz_route, queue: "#{Artery.service_name}.healthz.check" do |_data, reply, _from|
+        Artery.publish reply, status: :ok
+      end
+    end
+  end
+end

data/lib/artery/model/callbacks.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Artery
+  module Model
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+        after_create  :artery_on_create
+        after_update  :artery_on_update
+        after_destroy :artery_on_destroy
+
+        if respond_to?(:archival?) && archival?
+          after_archive   :artery_on_archive
+          after_unarchive :artery_on_unarchive
+        end
+      end
+
+      def artery_on_create
+        artery_notify_message(:create)
+      end
+
+      def artery_on_update
+        artery_notify_message(:update)
+      end
+
+      def artery_on_archive
+        artery_notify_message(:archive, archived_at: archived_at.to_f)
+      end
+
+      def artery_on_unarchive
+        artery_notify_message(:unarchive)
+      end
+
+      def artery_on_destroy
+        artery_notify_message(:delete)
+      end
+    end
+  end
+end

data/lib/artery/model/subscriptions.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Artery
+  module Model
+    module Subscriptions
+      extend ActiveSupport::Concern
+
+      ARTERY_MAX_UPDATES_SYNC              = 2000 # we should limit updates fetched at once
+      ARTERY_MAX_AUTOENRICHED_UPDATES_SYNC = 500  # we should limit updates fetched at once
+
+      included do
+        artery_add_get_subscriptions if artery_source_model?
+
+        attr_accessor :artery_updated_by_service
+      end
+
+      module ClassMethods
+        def artery_find_all(uuids)
+          where "#{artery_uuid_attribute}": uuids
+        end
+
+        def artery_find(uuid)
+          artery_find_all([uuid]).first
+        end
+
+        def artery_resync!
+          return false if artery_source_model?
+
+          artery[:subscriptions]&.detect(&:synchronize?)&.receive_all
+        end
+
+        def artery_add_subscription(uri, options = {}, &blk)
+          raise ArgumentError, 'block must be provided to handle subscription updates' unless block_given?
+
+          handler ||= Multiblock.wrapper
+
+          if uri.action.blank? || uri.action.to_s == '*'
+            yield(handler)
+          else
+            handler._default(&blk)
+          end
+
+          artery[:subscriptions] ||= []
+          artery[:subscriptions].push Subscription.new(self, uri, **options.merge(handler: handler))
+        end
+
+        def artery_watch_model(service:, model: nil, action: nil, **kwargs, &blk)
+          model  ||= artery_model_name
+          action ||= '*'
+
+          artery_add_subscription Routing.uri(service: service, model: model, action: action), kwargs, &blk
+        end
+
+        # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        def artery_add_get_subscriptions
+          artery_add_subscription Routing.uri(model: artery_model_name_plural, action: :get) do |data, reply, sub|
+            Artery.logger.info "HEY-HEY-HEY, message on GET with arguments: `#{[data, reply, sub].inspect}`!"
+            obj = artery_find data['uuid']
+
+            representation = data['representation']
+
+            data = obj.blank? ? { error: 'not_found' } : obj.to_artery(representation)
+
+            Artery.publish(reply, data)
+          end
+
+          artery_add_subscription Routing.uri(model: artery_model_name_plural, action: :get_all) do |data, reply, sub|
+            Artery.logger.info "HEY-HEY-HEY, message on GET_ALL with arguments: `#{[data, reply, sub].inspect}`!"
+
+            scope    = "artery_#{data['scope'] || 'all'}"
+            per_page = data['per_page']
+            page     = data['page'] || 0
+
+            representation = data['representation']
+
+            data = if respond_to?(scope)
+                     relation = send(scope)
+                     relation = relation.offset(page * per_page).limit(per_page) if per_page
+                     objects = relation.map { |obj| obj.to_artery(representation) }
+                     {
+                       objects: objects,
+                       _index: Artery.message_class.latest_index(artery_model_name)
+                     }
+                   else
+                     Artery.logger.error "No artery scope '#{data['scope']}' defined!"
+                     { error: 'No such scope!' }
+                   end
+
+            Artery.publish(reply, data)
+          end
+
+          artery_add_subscription Routing.uri(model: artery_model_name_plural,
+                                              action: :get_updates) do |data, reply, sub|
+            Artery.logger.info "HEY-HEY-HEY, message on GET_UPDATES with arguments: `#{[data, reply, sub].inspect}`!"
+
+            index = data['after_index'].to_i
+            autoenrich = data['representation'].present?
+            per_page = data['per_page'] || (autoenrich ? ARTERY_MAX_AUTOENRICHED_UPDATES_SYNC : ARTERY_MAX_UPDATES_SYNC)
+
+            if index.positive?
+              messages = Artery.message_class.after_index(artery_model_name, index).limit(per_page)
+            else
+              Artery.publish(reply, error: :bad_index)
+              return
+            end
+
+            # Deduplicate
+            messages = messages.to_a.group_by { |m| [m.action, m.data] }.values
+                               .map { |mm| mm.max_by { |m| m.index.to_i } }
+                               .sort_by { |m| m.index.to_i }
+
+            latest_index = Artery.message_class.latest_index(artery_model_name)
+            updates_latest_index = messages.last&.index || latest_index
+
+            Artery.logger.info "MESSAGES: #{messages.inspect}"
+
+            # Autoenrich data
+            if autoenrich
+              scope = "artery_#{data['scope'] || 'all'}"
+              autoenrich_data = send(scope).artery_find_all(messages.map { |m| m.data['uuid'] }).to_h do |obj|
+                [obj.send(artery_uuid_attribute), obj.to_artery(data['representation'])]
+              end
+            end
+
+            updates = messages.map do |message|
+              upd = message.to_artery.merge('action' => message.action)
+              if %i[create update].include?(message.action.to_sym) && # WARNING: duplicated logic with `Subscription#handle`!
+                 autoenrich_data &&
+                 (attrs = autoenrich_data[message.data['uuid']])
+                upd['attributes'] = attrs
+              end
+              upd
+            end
+
+            Artery.publish(reply, updates: updates,
+                                  _index: updates_latest_index, _continue: updates_latest_index < latest_index)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      end
+
+      def artery_updated_by!(service)
+        self.artery_updated_by_service = service
+      end
+    end
+  end
+end

data/lib/artery/model.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Artery
+  module Model
+    autoload :Subscriptions,  'artery/model/subscriptions'
+    autoload :Callbacks,      'artery/model/callbacks'
+
+    def artery_model(options = {})
+      extend ClassMethods
+      include InstanceMethods
+
+      options[:name] ||= to_s.demodulize.underscore.to_sym
+      options[:source] = false if options[:source].nil?
+      options[:uuid_attribute] = :uuid if options[:uuid_attribute].nil?
+
+      class_attribute :artery, instance_writer: false
+
+      self.artery = options.merge(representations: {
+                                    _default: proc { attributes }
+                                  })
+
+      include Subscriptions
+      include Callbacks if artery_source_model?
+
+      artery_scope :all, -> { all }
+    end
+
+    module ClassMethods
+      # Always clone artery configuration in subclass from parent class
+      def inherited(_sub_class)
+        self.artery = artery.clone
+        super
+      end
+
+      def artery_model_name
+        artery[:name]
+      end
+
+      def artery_model_name_plural
+        artery_model_name.to_s.pluralize.to_sym
+      end
+
+      def artery_source_model?
+        artery[:source]
+      end
+
+      def artery_uuid_attribute
+        artery[:uuid_attribute]
+      end
+
+      def artery_representation(*services, &blk)
+        services.each do |service_name|
+          artery[:representations][service_name.to_sym] = blk
+        end
+      end
+
+      def artery_default_representation(&blk)
+        artery_representation :_default, &blk
+      end
+
+      def artery_version(version = nil)
+        if version
+          artery[:version] = version
+        else
+          artery[:version] || 'v1'
+        end
+      end
+
+      def artery_scope(name, lmbd)
+        scope :"artery_#{name}", lmbd
+      end
+    end
+
+    module InstanceMethods
+      def artery_notify_message(action, extra_data = {})
+        Artery.message_class.create! model: self.class.artery_model_name,
+                                     action: action,
+                                     #  version: self.class.artery_version, TODO:
+                                     data: { uuid: artery_uuid,
+                                             updated_by_service: artery_updated_by_service }.merge(extra_data)
+      end
+
+      def artery_uuid
+        send(self.class.artery_uuid_attribute)
+      end
+
+      def to_artery(representation_name = nil)
+        if representation_name && artery[:representations].key?(representation_name.to_sym)
+          instance_eval(&artery[:representations][representation_name.to_sym])
+        else
+          instance_eval(&artery[:representations][:_default])
+        end
+      end
+    end
+  end
+end

data/lib/artery/no_brainer/message.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Artery
+  module NoBrainer
+    class Message
+      include MessageModel
+      include ::NoBrainer::Document
+
+      table_config name: 'artery_messages'
+
+      field :created_at_f, type: Float
+
+      field :version, type: String
+      field :model,   type: String, required: true
+      field :action,  type: String, required: true
+      field :data,    type: Hash,   required: true
+      field :_index,  type: Integer, index: true
+
+      alias index _index
+
+      after_save :send_to_artery
+
+      around_create :lock_on_model
+      before_create :assign_index
+
+      class << self
+        def after_index(model, index)
+          where(model: model, :_index.gt => index).order(:_index)
+        end
+
+        def latest_index(model)
+          where(model: model).max(:_index)&.index.to_i
+        end
+
+        def delete_old
+          where(:created_at_f.lt => MAX_MESSAGE_AGE.ago.to_f).delete_all
+        end
+      end
+
+      def _create(options = {})
+        now = Time.zone.now
+        self.created_at_f = now.to_f.round(6) unless created_at_f_changed?
+        super
+      end
+
+      def previous_index
+        return 0 unless index
+
+        self.class.where(model: model, :_index.lt => index).max(:_index)&.index
+      end
+
+      def to_artery
+        data.merge('_index' => index)
+      end
+
+      protected
+
+      def lock_on_model(&block)
+        ::NoBrainer::Lock.new("#{self.class.table_name}:#{model}").synchronize(&block)
+      end
+
+      def assign_index
+        self._index = self.class.latest_index(model).next
+      end
+    end
+  end
+end

data/lib/artery/no_brainer/subscription_info.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Artery
+  module NoBrainer
+    class SubscriptionInfo
+      include ::NoBrainer::Document
+
+      table_config name: 'artery_subscription_infos'
+
+      field :subscriber, type: String, required: true
+      field :service,    type: String, required: true
+      field :model,      type: String, required: true
+
+      field :latest_index, type: Integer
+
+      field :synchronization_in_progress, type: Boolean, required: true, default: false
+      field :synchronization_heartbeat,   type: Time,    required: false
+      field :synchronization_page,        type: Integer, required: false
+
+      class << self
+        def find_for_subscription(subscription)
+          params = {
+            subscriber: subscription.subscriber.to_s,
+            service: subscription.uri.service,
+            model: subscription.uri.model
+          }
+
+          info = where(params).first || new(params)
+
+          info.save! if info.new_record?
+          info
+        end
+      end
+
+      def with_lock
+        was_locked = @lock.present?
+
+        if was_locked # only 'indexed' messages should lock
+          yield
+        else
+          Artery.logger.debug "WAITING FOR LOCK... [LATEST_INDEX: #{latest_index}]"
+
+          lock = ::NoBrainer::Lock.new("artery_subscription_info:#{model}")
+
+          lock.synchronize do
+            Artery.logger.debug "GOT LOCK! [LATEST_INDEX: #{latest_index}]"
+            reload # need fresh record
+
+            @lock = lock
+
+            yield
+          end
+        end
+      ensure
+        @lock = nil unless was_locked
+      end
+
+      def lock_for_message(message, &blk)
+        if message.has_index? # only 'indexed' messages should lock
+          with_lock(&blk)
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/artery/no_brainer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Artery
+  module NoBrainer
+    autoload :Message,          'artery/no_brainer/message'
+    autoload :SubscriptionInfo, 'artery/no_brainer/subscription_info'
+  end
+end