gorynich 1.1.0.142046

data/lib/gorynich/config.rb

@@ -0,0 +1,241 @@
+module Gorynich
+  class Config
+    attr_reader :fetcher,
+                :tenants,
+                :databases,
+                :hosts,
+                :uris,
+                :default
+
+    #
+    # Create instance of config
+    #
+    # @param [Fetcher] fetcher data loader
+    #
+    def initialize(**opts)
+      @default = 'default'
+      @fetcher = opts.fetch(:fetcher, Fetcher.new)
+      @mx = Mutex.new
+
+      actualize
+    end
+
+    #
+    # Update configs from data source
+    #
+    def actualize
+      cfg = fetcher.fetch.fetch(Rails.env)
+
+      @mx.synchronize do
+        @tenants = tenants_from_config(cfg)
+        @databases = databases_from_config(cfg)
+        @secrets = secrets_from_config(cfg)
+        @uris = uris_from_config(@secrets)
+        @hosts = hosts_from_config(@secrets)
+      end
+    end
+
+    #
+    # Database config
+    #
+    # @param [String, Symbol] tenant
+    #
+    # @return [Hash]
+    #
+    def database(tenant)
+      databases.fetch(tenant.to_s)
+    rescue StandardError
+      raise TenantNotFound, tenant
+    end
+
+    %i[uris hosts secrets].each do |name|
+      define_method(name) do |tenant = nil|
+        values = instance_variable_get("@#{name}")
+        return values if tenant.nil?
+
+        values.fetch(tenant.to_s)
+      rescue StandardError
+        raise TenantNotFound, tenant
+      end
+    end
+
+    #
+    # Find tenant by URI
+    #
+    # @param [String] uri
+    #
+    # @return [String]
+    #
+    def tenant_by_uri(uri)
+      uri = URI(uri)
+      search_tenant = uris.select do |tenant, tenant_uris|
+        tenant if tenant_uris.map { |t_uri| URI(t_uri) }.include?(uri)
+      end.keys.first
+
+      raise UriNotFound, uri.host if search_tenant.nil?
+
+      search_tenant
+    end
+
+    #
+    # Find tenant by host
+    #
+    # @param [String] host
+    #
+    # @return [String]
+    #
+    def tenant_by_host(host)
+      tenant = hosts.select { |t, h| t if h.include?(host) }.keys.first
+      raise HostNotFound, host if tenant.nil?
+
+      tenant
+    end
+
+    #
+    # Find URI by host
+    #
+    # @param [String] host
+    # @param [String, Symbol] tenant tenant of config (optional)
+    #
+    # @return [String]
+    #
+    def uri_by_host(host, tenant = nil)
+      tenant ||= tenant_by_host(host)
+      tenant_uris = uris(tenant)
+      search_uri = tenant_uris.select { |uri| uri.include?(host) }.first
+
+      raise UriNotFound, search_uri.host if search_uri.nil?
+
+      search_uri
+    end
+
+    #
+    # Full config from data source by tenant
+    #
+    # @param [String, Symbol] tenant
+    #
+    # @return [Hash]
+    #
+    def config(tenant)
+      {
+        tenant: tenant.to_s,
+        database: database(tenant),
+        secrets: secrets(tenant)
+      }
+    end
+
+    #
+    # Database config for database.yml
+    #
+    # @param [String] env enviroment
+    # @param [Boolean] with_ignore ignore if there is no configuration for the environment
+    #
+    # @return [String] yaml result
+    #
+    def database_config(env = nil, fail_ignore: false)
+      envs = Dir.glob(Rails.root.join('config/environments/*.rb').to_s).map { |f| File.basename(f, '.rb') }
+      cfg = fetcher.fetch.extract!(*envs)
+
+      result =
+        if env.nil?
+          cfg.to_h do |cfg_env, tenant_cfg|
+            [
+              cfg_env,
+              configs_sort(tenant_cfg).to_h { |t, c| [t, c.fetch('db_config')] }
+            ]
+          end
+        else
+          if fail_ignore && cfg.fetch(env, nil).nil?
+            { env => nil}
+          else
+            {
+              env => configs_sort(cfg.fetch(env)).to_h { |t, c| [t, c.fetch('db_config')] }
+            }
+          end
+        end
+
+      result.to_yaml.gsub('---', '')
+    end
+
+    #
+    # For connection to ActiveRecord
+    #
+    # @return [Hash]
+    #
+    def connects_to_config
+      actualize
+      tenants.each_with_object({ default: :default }) do |tenant, cfg|
+        cfg[tenant.to_sym] = tenant.to_sym
+      end
+    end
+
+    private
+
+    def databases_from_config(cfg)
+      cfg.to_h { |tenant, config| [tenant, config.fetch('db_config')] }
+    end
+
+    def tenants_from_config(cfg)
+      available_tenants = cfg.keys
+      raise TenantNotFound, default unless available_tenants.include?(default)
+
+      available_tenants
+    end
+
+    def secrets_from_config(cfg)
+      cfg.to_h { |tenant, config| [tenant, config.fetch('secrets', {})] }
+    end
+
+    def uris_from_config(secrets_by_tenant)
+      secrets_by_tenant.to_h { |tenant, secrets| [tenant, processed_uris(secrets)] }
+    end
+
+    def hosts_from_config(secrets_by_tenant)
+      secrets_by_tenant.to_h do |tenant, secrets|
+        hosts = processed_uris(secrets).map { |uri| URI(uri).host }
+        [tenant, hosts]
+      end
+    end
+
+    #
+    # Make default database first in the list
+    #
+    # @param [Hash] cfg config of enviroment
+    #
+    # @return [Hash]
+    #
+    def configs_sort(cfg)
+      sorted_config = { 'default' => cfg['default'] }
+      sorted_config.merge!(cfg)
+    end
+
+    # consul KV can store only array into json string, so need to parse
+    def processed_uris(secrets)
+      secrets_uris = secrets.fetch('uris', [])
+      is_array = secrets_uris.is_a?(Array)
+      return secrets_uris if is_array && secrets_uris.empty?
+
+      if is_array
+        validate_uris(secrets_uris)
+        return secrets_uris
+      end
+
+      secrets_uris = JSON.parse(secrets_uris)
+      validate_uris(secrets_uris)
+      secrets_uris
+    rescue JSON::ParserError => e
+      raise ConfigError, 'URI parse error. Must be an array of URI'
+    end
+
+    def valid_url?(uri)
+      uri = URI.parse(uri)
+      !!uri.host && !!uri.scheme
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def validate_uris(secrets_uris)
+      secrets_uris.each { |uri| raise ConfigError, 'URI parse error. Must be an array of URI' unless valid_url?(uri) }
+    end
+  end
+end

data/lib/gorynich/configuration.rb

@@ -0,0 +1,17 @@
+module Gorynich
+  class Configuration
+    attr_accessor :cache,
+                  :fetcher,
+                  :namespace,
+                  :cache_expiration,
+                  :rack_env_handler
+
+    def initialize
+      @cache = ActiveSupport::Cache::NullStore.new
+      @fetcher = nil
+      @namespace = nil
+      @cache_expiration = 30
+      @rack_env_handler = nil
+    end
+  end
+end

data/lib/gorynich/current.rb

@@ -0,0 +1,13 @@
+module Gorynich
+  class Current < ::ActiveSupport::CurrentAttributes
+    attribute :tenant
+    attribute :uri
+    attribute :host
+    attribute :secrets
+    attribute :database
+
+    def secrets
+      super || {}
+    end
+  end
+end

data/lib/gorynich/engine.rb

@@ -0,0 +1,11 @@
+module Gorynich
+  class Engine < ::Rails::Engine
+    isolate_namespace Gorynich
+
+    initializer 'gorynich.add_middleware' do |app|
+      app.middleware.insert_after ActionDispatch::RemoteIp, Gorynich::Head::RackMiddleware
+      app.config.active_record.writing_role = :default
+      app.config.hosts.clear
+    end
+  end
+end

data/lib/gorynich/fetcher.rb

@@ -0,0 +1,54 @@
+require_relative 'fetchers/file'
+require_relative 'fetchers/consul'
+
+module Gorynich
+  class Fetcher
+    attr_reader :fetcher, :namespace, :cache_expiration
+
+    #
+    # Create instance of fetcher
+    #
+    # @param [Object] fetcher data source
+    # @param [String, Symbol] namespace cache namespace
+    # @param [Integer] cache_expiration how long your cache will be alive
+    #
+    def initialize(fetcher: nil, namespace: nil, cache_expiration: nil)
+      @fetcher = fetcher || Gorynich.configuration.fetcher
+      @namespace = namespace || Gorynich.configuration.namespace
+      @cache_expiration = cache_expiration || Gorynich.configuration.cache_expiration
+    end
+
+    #
+    # Load data from source
+    #
+    # @return [Hash]
+    #
+    def fetch
+      cfg = Gorynich.configuration.cache.fetch(
+        %i[gorynich fetcher fetch], expires_in: @cache_expiration.seconds, namespace: @namespace
+      ) do
+        if @fetcher.nil?
+          {}
+        elsif @fetcher.is_a?(Array)
+          result = {}
+          @fetcher.each do |f|
+            result = 
+              begin
+                f.fetch
+              rescue ::StandardError
+                {}
+              end
+            break unless result.empty?
+          end
+          result
+        else
+          @fetcher.fetch
+        end
+      end
+
+      raise Error, 'Config is empty' if cfg.empty?
+
+      cfg.deep_transform_keys(&:downcase)
+    end
+  end
+end

data/lib/gorynich/fetchers/consul.rb

@@ -0,0 +1,19 @@
+require 'diplomat'
+
+module Gorynich
+  module Fetchers
+    class Consul
+      attr_reader :storage, :consul_opts
+
+      def initialize(storage:, **opts)
+        @storage = storage
+        @consul_opts = opts
+      end
+
+      def fetch
+        config = ::Diplomat::Kv.get_all(storage, convert_to_hash: true, **consul_opts)
+        config.dig(*storage.split('/')) || {}
+      end
+    end
+  end
+end

data/lib/gorynich/fetchers/file.rb

@@ -0,0 +1,22 @@
+require 'erb'
+require 'yaml'
+
+module Gorynich
+  module Fetchers
+    class File
+      attr_reader :file_path
+
+      def initialize(file_path:)
+        @file_path = file_path
+      end
+
+      def fetch
+        data = ::ERB.new(::File.read(file_path)).result
+
+        ::YAML.load(data, aliases: true) || {}
+      rescue ArgumentError
+        ::YAML.load(data) || {}
+      end
+    end
+  end
+end

data/lib/gorynich/head/action_cable.rb

@@ -0,0 +1,44 @@
+module Gorynich
+  module Head
+    module ActionCable
+      module Connection
+        extend ::ActiveSupport::Concern
+
+        included do
+          attr_reader :host, :tenant
+
+          def connect
+            @host = env['SERVER_NAME']
+            @tenant = ::Gorynich.instance.tenant_by_host(@host)
+          end
+        end
+      end
+
+      module Channel
+        def subscribe_to_channel(*args)
+          ::Gorynich.with(tenant, host: host) do
+            super
+          end
+        end
+
+        def unsubscribe_from_channel(*args)
+          ::Gorynich.with(tenant, host: host) do
+            super
+          end
+        end
+
+        def perform_action(*args)
+          ::Gorynich.with(tenant, host: host) do
+            super
+          end
+        end
+
+        def self.broadcasting_for(model)
+          raise 'unable to broadcast message without tenant' if ::Gorynich::Current.tenant.nil?
+
+          serialize_broadcasting([channel_name, ::Gorynich::Current.tenant, model])
+        end
+      end
+    end
+  end
+end

data/lib/gorynich/head/active_job.rb

@@ -0,0 +1,36 @@
+module Gorynich
+  module Head
+    module ActiveJob
+      extend ::ActiveSupport::Concern
+
+      included do
+        attr_reader :current_uri, :current_tenant
+
+        def serialize
+          super.merge(uri: Gorynich::Current.uri, tenant: Gorynich::Current.tenant)
+        end
+
+        def deserialize(job_data)
+          super
+          @current_uri = job_data.fetch(:uri)
+          @current_tenant = job_data.fetch(:tenant)
+        end
+
+        around_perform do |job, block|
+          Gorynich.with(
+            job.current_tenant || Gorynich::Current.tenant,
+            uri: job.current_uri || Gorynich::Current.uri
+          ) do |_current|
+            block.call
+          end
+        end
+
+        around_enqueue do |_job, block|
+          Gorynich.with_database(Gorynich.instance.default) do
+            block.call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gorynich/head/active_record.rb

@@ -0,0 +1,46 @@
+module Gorynich
+  module Head
+    module ActiveRecord
+      extend ActiveSupport::Concern
+
+      included do
+        module ::GlobalID::Locator
+          class << self
+            def original_locate(gid, options = {})
+              if (gid = GlobalID.parse(gid)) && find_allowed?(gid.model_class, options[:only])
+                locator_for(gid).locate gid
+              end
+            end
+
+            def locate(gid, options = {})
+              gid = GlobalID.parse(gid)
+              return original_locate(gid, options) unless gid
+
+              tenant = gid.params['tenant']
+              if tenant && tenant != Gorynich::Current.tenant
+                Gorynich.with(tenant) do
+                  original_locate(gid, options)
+                end
+              else
+                original_locate(gid, options)
+              end
+            end
+          end
+        end
+
+        connects_to database: Gorynich.instance.connects_to_config
+
+        def cache_key(*args)
+          "#{Gorynich::Current.tenant}:#{super}"
+        end
+
+        def to_global_id(options = {})
+          options[:tenant] ||= Gorynich::Current.tenant
+          super
+        end
+
+        alias_method :to_gid, :to_global_id
+      end
+    end
+  end
+end

data/lib/gorynich/head/delayed_job.rb

@@ -0,0 +1,22 @@
+# Do not require this until want to use DelayedJob
+
+module Gorynich
+  module Head
+    class DelayedJob < ::Delayed::Plugin
+
+      callbacks do |lifecycle|
+        lifecycle.around(:execute) do |*_args, &block|
+          Gorynich.with(Gorynich.instance.default) do |current|
+            if ::Delayed::Worker.logger.respond_to?(:tagged)
+              ::Delayed::Worker.logger.tagged(tenant: current.tenant) { block.call }
+            else
+              block.call
+            end
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/gorynich/head/rack_middleware.rb

@@ -0,0 +1,34 @@
+# connects_to database:
+module Gorynich
+  module Head
+    class RackMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @config ||= Gorynich.instance
+        @config.actualize
+
+        tenant, opts = Gorynich.switcher.analyze(env)
+
+        Gorynich.with(tenant, **opts) do
+          if Rails.logger.respond_to?(:tagged)
+            Rails.logger.tagged("Tenant(#{tenant})") { @app.call(env) }
+          else
+            @app.call(env)
+          end
+        end
+      rescue Gorynich::UriNotFound => e
+        Rails.logger.error(e.inspect)
+        [404, { 'Content-Type' => 'text/plain', 'charset' => 'UTF-8' }, [e.message]]
+      rescue Gorynich::HostNotFound => e
+        Rails.logger.error(e.inspect)
+        [404, { 'Content-Type' => 'text/plain', 'charset' => 'UTF-8' }, [e.message]]
+      rescue Gorynich::TenantNotFound => e
+        Rails.logger.error(e.inspect)
+        [404, { 'Content-Type' => 'text/plain', 'charset' => 'UTF-8' }, [e.message]]
+      end
+    end
+  end
+end

data/lib/gorynich/head.rb

@@ -0,0 +1,9 @@
+require_relative 'head/rack_middleware'
+require_relative 'head/active_record'
+require_relative 'head/action_cable'
+require_relative 'head/active_job'
+
+module Gorynich
+  module Head
+  end
+end

data/lib/gorynich/switcher.rb

@@ -0,0 +1,48 @@
+module Gorynich
+  class Switcher
+    def initialize(config:)
+      @config = config
+    end
+
+    #
+    # Hander for rack middleware's variables
+    #
+    # @param [Hash] env middleware's variables
+    #
+    # @return [[String, Hash]] tenant, options
+    #
+    def analyze(env)
+      return Gorynich.configuration.rack_env_handler.call(env) unless Gorynich.configuration.rack_env_handler.nil?
+
+      host = env['SERVER_NAME']
+      tenant = Gorynich.instance.tenant_by_host(host)
+      uri = Gorynich.instance.uri_by_host(host, tenant)
+      [tenant, { host: host, uri: uri }]
+    end
+
+    def with_database(tenant)
+      ::ActiveRecord::Base.connected_to role: tenant.to_sym do
+        yield(tenant)
+      end
+    end
+
+    def with_current(tenant, **opts, &block)
+      Gorynich::Current.set(@config.config(tenant.to_s).merge(opts)) do
+        block.call(Gorynich::Current.instance) if block.present?
+      end
+    end
+
+    def with(tenant, **opts, &block)
+      with_database(tenant) do
+        with_current(tenant, **opts, &block)
+      end
+    end
+
+    def with_each_tenant(except: [], &block)
+      except = except.map(&:to_s)
+      @config.tenants.reject { |v| except.include?(v) }.each do |tenant|
+        with(tenant, &block)
+      end
+    end
+  end
+end

data/lib/gorynich/version.rb

@@ -0,0 +1,3 @@
+module Gorynich
+  VERSION = '1.1.0'
+end