artery 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e98c3102570a6fbac048ecad94e61d537475a13e74d64108d41a5538e209a65
+  data.tar.gz: b1d4dee0d394e6d3e358a8bcf53d46130ec4f6cb342bcbfddf281b8700d3d8d5
+SHA512:
+  metadata.gz: 0afa95d312f8863dfcec43024bd910552021176eea27779ed34eca7f8d4ff36031e0b62572a8ca234d893eaa1e739eed3e4774e5e4a566d7564b2b1dede49ad8
+  data.tar.gz: 272299e4ad9c8df1fa915e53d1629ea102187c0e828e17d3d714d0d792ead53cf64539b1a9819a79337c890c5ee30521b03efaf026a371684c7f64edd1e5d753

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Sergey Gnuskov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Artery
+Main messaging system between Rails [micro]services implementing message bus pattern on NATS (for now).
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'artery'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install artery
+```
+
+Then install migrations and run (if using ActiveRecord):
+```bash
+$ rake artery:install:migrations
+$ rake db:migrate
+```
+
+## Admin interface
+
+In admin interface you can list your artery endpoints and check their statuses.
+You can mount admin ui to your routes via:
+```ruby
+mount Artery::Engine => '/artery'
+```
+And then you can access it by url `http(s)://{ your_app_url }/artery/`.
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Artery'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/app/models/concerns/artery/message_model.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Artery
+  module MessageModel
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+      MAX_MESSAGE_AGE = ENV.fetch('ARTERY_MAX_MESSAGE_AGE', '90').to_i.days
+
+      def after_index(model, index)
+        raise NotImplementedError
+      end
+
+      def latest_index(model)
+        raise NotImplementedError
+      end
+
+      def delete_old
+        raise NotImplementedError
+      end
+    end
+
+    def uri
+      Artery::Routing.uri(model: model, action: action)
+    end
+
+    def uri=(uri)
+      self.model   = uri.model
+      self.action  = uri.action
+    end
+
+    def route
+      uri.to_route
+    end
+
+    def to_artery
+      data.merge('_index' => index)
+    end
+
+    def previous_index
+      raise NotImplementedError
+    end
+
+    protected
+
+    def send_to_artery
+      Artery.publish route, to_artery.merge('_previous_index' => previous_index)
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+Artery::Engine.routes.draw do
+end

data/db/migrate/20170110090949_create_artery_messages.rb

@@ -0,0 +1,14 @@
+class CreateArteryMessages < ActiveRecord::Migration[5.0]
+  def change
+    create_table :artery_messages do |t|
+      t.string    :version
+
+      t.string    :model,      null:  false
+      t.string    :action,     null:  false
+
+      t.text      :data,       null:  false
+
+      t.timestamp :created_at, limit: 6
+    end
+  end
+end

data/db/migrate/20170116143013_create_artery_last_model_updates.rb

@@ -0,0 +1,10 @@
+class CreateArteryLastModelUpdates < ActiveRecord::Migration[5.0]
+  def change
+    create_table :artery_last_model_updates do |t|
+      t.string :service, null: false
+      t.string :model,   null: false
+
+      t.timestamp :last_message_at, limit: 6, null: false
+    end
+  end
+end

data/db/migrate/20170420155129_change_last_model_updates_to_subscription_infos.rb

@@ -0,0 +1,17 @@
+class ChangeLastModelUpdatesToSubscriptionInfos < ActiveRecord::Migration[5.0]
+  def up
+    rename_table :artery_last_model_updates, :artery_subscription_infos
+
+    change_column :artery_subscription_infos, :last_message_at, :timestamp, limit: 6, null: true
+    add_column :artery_subscription_infos, :synchronization_in_progress, :boolean, default: false
+    add_column :artery_subscription_infos, :synchronization_page, :integer
+  end
+
+  def down
+    remove_column :artery_subscription_infos, :synchronization_in_progress
+    remove_column :artery_subscription_infos, :synchronization_page
+    change_column :artery_subscription_infos, :last_message_at, :timestamp, limit: 6, null: false
+
+    rename_table :artery_subscription_infos, :artery_last_model_updates
+  end
+end

data/db/migrate/20171020104646_add_subscriber_to_artery_subscription_infos.rb

@@ -0,0 +1,5 @@
+class AddSubscriberToArterySubscriptionInfos < ActiveRecord::Migration[5.0]
+  def change
+    add_column :artery_subscription_infos, :subscriber, :string, after: :id
+  end
+end

data/db/migrate/20181211110018_add_latest_index_to_artery_subscription_infos.rb

@@ -0,0 +1,5 @@
+class AddLatestIndexToArterySubscriptionInfos < ActiveRecord::Migration[5.0]
+  def change
+    add_column :artery_subscription_infos, :latest_index, :integer, unsigned: true
+  end
+end

data/db/migrate/20200109120304_add_index_on_model_to_artery_messages.rb

@@ -0,0 +1,9 @@
+class AddIndexOnModelToArteryMessages < ActiveRecord::Migration[5.2]
+  def up
+    add_index :artery_messages, :model unless index_exists?(:artery_messages, :model)
+  end
+
+  def down
+    remove_index :artery_messages, :model
+  end
+end

data/db/migrate/20200109120305_remove_last_message_at_from_artery_subscription_infos.rb

@@ -0,0 +1,9 @@
+class RemoveLastMessageAtFromArterySubscriptionInfos < ActiveRecord::Migration[5.2]
+  def up
+    remove_column :artery_subscription_infos, :last_message_at if column_exists?(:artery_subscription_infos, :last_message_at)
+  end
+
+  def down
+    add_column :artery_subscription_infos, :last_message_at, :timestamp
+  end
+end

data/db/migrate/20240411120304_add_synchronization_heartbeat_to_artery_subscription_infos.rb

@@ -0,0 +1,11 @@
+class AddSynchronizationHeartbeatToArterySubscriptionInfos < ActiveRecord::Migration[5.2]
+  def up
+    return if column_exists?(:artery_subscription_infos, :synchronization_heartbeat)
+
+    add_column :artery_subscription_infos, :synchronization_heartbeat, :timestamp, after: :synchronization_in_progress
+  end
+
+  def down
+    remove_column :artery_subscription_infos, :synchronization_heartbeat
+  end
+end

data/exe/artery-check

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require ENV['APP_PATH'] || File.join(File.expand_path('.'), 'config', 'application')
+
+Rails.application.initialize!
+Rails.application.eager_load!
+
+Artery::Check.run ARGV.map(&:strip)

data/exe/artery-clean

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require ENV['APP_PATH'] || File.join(File.expand_path('.'), 'config', 'application')
+
+Rails.application.initialize!
+Rails.application.eager_load!
+
+Artery.message_class.delete_old

data/exe/artery-sync

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require ENV['APP_PATH'] || File.join(File.expand_path('.'), 'config', 'application')
+
+Rails.application.initialize!
+Rails.application.eager_load!
+
+Artery::Sync.run ARGV.map(&:strip)

data/exe/artery-worker

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require ENV['APP_PATH'] || File.join(File.expand_path('.'), 'config', 'application')
+
+Rails.application.initialize!
+Rails.application.eager_load!
+
+Artery::Worker.new.run ARGV.map(&:strip)

data/lib/artery/active_record/message.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Artery
+  module ActiveRecord
+    class Message < ::ActiveRecord::Base
+      include MessageModel
+
+      self.table_name = 'artery_messages'
+
+      serialize :data, coder: JSON
+
+      after_commit :send_to_artery, on: :create
+
+      alias index id
+
+      class << self
+        def after_index(model, index)
+          where(model: model)
+            .where(arel_table[:id].gt(index)).order(:id)
+        end
+
+        def latest_index(model)
+          where(model: model).last&.id.to_i
+        end
+
+        def delete_old
+          max_aged_id = where(arel_table[:created_at].lt(MAX_MESSAGE_AGE.ago)).maximum(:id)
+          where(arel_table[:id].lteq(max_aged_id)).delete_all if max_aged_id.to_i.positive?
+        end
+      end
+
+      # It is used in after_commit, so we always know previous index based on our current index
+      def previous_index
+        scope = self.class.where(model: model).order(:id)
+        scope = scope.where(self.class.arel_table[:id].lt(index)) if index
+
+        scope.select(:id).last&.id.to_i
+      end
+    end
+  end
+end

data/lib/artery/active_record/subscription_info.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Artery
+  module ActiveRecord
+    class SubscriptionInfo < ::ActiveRecord::Base
+      self.table_name = 'artery_subscription_infos'
+
+      class << self
+        def find_for_subscription(subscription)
+          info = find_or_initialize_by(subscriber: subscription.subscriber.to_s,
+                                       service: subscription.uri.service,
+                                       model: subscription.uri.model)
+
+          info.save! if info.new_record?
+          info
+        end
+      end
+
+      def synchronization_transaction(&block)
+        with_lock(&block)
+      end
+
+      def with_lock
+        self.class.transaction do
+          unless (was_locked = @locked) # prevent double lock to reduce selects
+            Artery.logger.debug "WAITING FOR LOCK...  [LATEST_INDEX: #{latest_index}]"
+
+            reload lock: true # explicitely reload record
+
+            Artery.logger.debug "GOT LOCK! [LATEST_INDEX: #{latest_index}]"
+
+            @locked = true
+          end
+
+          yield
+        ensure
+          @locked = false unless was_locked
+        end
+      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/active_record.rb

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

data/lib/artery/backend.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Artery
+  module Backend
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_reader :backend_in_use, :backends
+
+        def register_backend(type, class_name)
+          @backends ||= {}
+          @backends[type.to_sym] = class_name
+        end
+
+        def use_backend(type)
+          type = type.to_sym
+          raise ArgumentError, "Artery has no registered backend '#{type}'" unless backends.key?(type)
+
+          @backend_in_use = type
+
+          @backend&.stop
+          @backend = nil
+        end
+
+        def backend
+          @backend ||= begin
+            backend_class = Artery::Backends.const_get(backends[backend_in_use])
+            backend_class.new backend_config
+          rescue LoadError, NameError => e
+            raise "Unable to load backend #{type}: #{e.message}"
+          end
+        end
+
+        delegate :start, :stop, :connect, :unsubscribe, to: :backend
+      end
+    end
+
+    module ClassMethods
+      def subscribe(route, options = {})
+        backend.subscribe(route, options) do |json, reply, from|
+          json = '{}' if json.blank?
+
+          yield(JSON.parse(json).with_indifferent_access, reply, from)
+        rescue StandardError => e
+          Artery.handle_error FormatError.new(from, json, original_exception: e,
+                                                          subscription: { route: from, data: json })
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def request(route, data = nil, options = {})
+        raise ArgumentError, 'You must provide block to handle response' unless block_given?
+
+        handler = Multiblock.wrapper
+        uri = Routing.uri(route)
+
+        yield(handler)
+
+        data ||= {}
+        Artery.logger.debug "REQUESTED: <#{uri.to_route}> #{data.to_json}"
+
+        backend.request(uri.to_route, data.to_json, options) do |message|
+          if message.is_a?(Error) # timeout case
+            Artery.logger.debug "REQUEST ERROR: <#{uri.to_route}> #{message.message}"
+            handler.call :error, message
+          else
+            Artery.logger.debug "REQUEST RESPONSE: <#{uri.to_route}> #{message}"
+            begin
+              message ||= '{}'
+              response = JSON.parse(message).with_indifferent_access
+
+              if response.key?(:error)
+                handler.call :error, RequestError.new(uri, response, request: { route: uri.to_route, data: data.to_json },
+                                                                     response: message)
+              else
+                handler.call :success, response
+              end
+            rescue JSON::ParserError => e
+              Artery.handle_error FormatError.new(uri, message, original_exception: e,
+                                                                request: { route: uri.to_route, data: data.to_json },
+                                                                response: message)
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def publish(route, data)
+        backend.publish(route, data.to_json)
+        Artery.logger.debug "PUBLISHED: <#{route}> #{data.to_json}"
+      end
+    end
+  end
+end

data/lib/artery/backends/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Artery
+  module Backends
+    class Base
+      attr_accessor :config
+
+      def initialize(config = {})
+        @config = config
+      end
+
+      def start(*_args)
+        raise NotImplementedError
+      end
+
+      def connect(*_args)
+        raise NotImplementedError
+      end
+
+      def subscribe(*_args)
+        raise NotImplementedError
+      end
+
+      def unsubscribe(*_args)
+        raise NotImplementedError
+      end
+
+      def publish(*_args)
+        raise NotImplementedError
+      end
+
+      def request(*_args)
+        raise NotImplementedError
+      end
+
+      def stop(*_args)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/artery/backends/fake.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# For the test environment
+module Artery
+  module Backends
+    class Fake < Base
+      def start(*_args); end
+
+      def connect(*_args); end
+
+      def subscribe(*_args); end
+
+      def unsubscribe(*_args); end
+
+      def publish(*_args); end
+
+      def request(_route, _data, _opts = {})
+        yield if block_given?
+      end
+
+      def stop(*_args); end
+    end
+  end
+end

data/lib/artery/backends/nats_pure.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'nats/client'
+
+module Artery
+  module Backends
+    class NATSPure < Base
+      def client
+        @client || connect
+      end
+
+      delegate :connected?, :connecting?, :subscribe, to: :client
+
+      def connect
+        @client ||= begin
+          client = ::NATS.connect(options)
+
+          client.on_reconnect do
+            Artery.logger.debug "Reconnected to server at #{client.connected_server}"
+          end
+
+          client.on_disconnect do
+            Artery.logger.debug 'Disconnected!'
+          end
+
+          client.on_close do
+            Artery.logger.debug 'Connection to NATS closed'
+          end
+          client
+        end
+
+        Artery.logger.debug "Connected to #{@client.connected_server}"
+        @client.connect unless @client.connected?
+
+        @client
+      end
+
+      def stop
+        client.close
+        @stop = true
+      end
+
+      def start
+        @stop = false
+        connect
+
+        yield
+
+        sleep 0.1 until @stop
+      end
+
+      def request(route, data, opts = {})
+        opts[:timeout] ||= Artery.request_timeout
+        # Always synchronous for now
+        response = client.request route, data, **opts
+        yield response.data
+      rescue ::NATS::Timeout
+        yield(TimeoutError.new(request: { route: route, data: data }))
+      end
+
+      def publish(route, data)
+        client.publish route, data
+      end
+
+      private
+
+      def options
+        options = {}
+
+        options[:servers] = config[:servers]  unless config[:servers].blank?
+        options[:user]    = config[:user]     unless config[:user].blank?
+        options[:pass]    = config[:password] unless config[:password].blank?
+
+        options[:reconnect_time_wait]    = config[:reconnect_timeout]  unless config[:reconnect_timeout].blank?
+        options[:max_reconnect_attempts] = config[:reconnect_attempts] unless config[:reconnect_attempts].blank?
+
+        if ENV.key?('NATS_URL')
+          options[:servers] ||= []
+          options[:servers] << ENV['NATS_URL']
+        end
+
+        options
+      end
+    end
+  end
+end