motor-admin 0.1.37 → 0.1.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c003af4059ae5bd3a60d30031526c1ed2aefd267c7e1f93f33e5bac94eaff5c7
-  data.tar.gz: aa7403bca65f0d936b86bcc58f1fe88b4081439d74843f1ca1c3d25fd4da8a81
+  metadata.gz: 2e0ab742c32ae1b59bfa12c6eb1f838e5d379cb5a964521fe7f345de5fabf953
+  data.tar.gz: 9f018c3475ae06b4104e35f30774c80b2098a8a23b7fa3a8e4ac35df089ee98e
 SHA512:
-  metadata.gz: a195dd04aceadc74e1d7fa89dc0100c15fc045c0fad238230567069801698d341d6a9e598b861ae9e802e61dd5a48915d15c74b88a1228deae5a985fad283762
-  data.tar.gz: 7d6dc23a2750dc941b20d83170dc3f2eb3018d02897b2500b99831285ac139fcde46ebfa7ae044be856504bac6f09e1d11e70c02a443eba6d70278b959784f74
+  metadata.gz: '0651978240824b17dc1f379047faf9f5c5a393b9bebe6e37ae692a606630a300454a2c56c88173383defef451787555006d355fe26c2dd38173f0ece03e116a0'
+  data.tar.gz: b15c006847a5c9dcea315741ccc3a46e3a2bba49ab05d2aceab44c75a530ba0f5fad79067aae0b8e31abad9cda105a827cbdb892d93fd1c2c1fe72a2f62a8637

data/app/controllers/motor/alerts_controller.rb

@@ -18,12 +18,15 @@ module Motor
     end
 
     def create
-      ApplicationRecord.transaction { @alert.save! }
-      Motor::Alerts::ScheduledAlertsCache.clear
-
-      render json: { data: Motor::ApiQuery::BuildJson.call(@alert, params) }
-    rescue Motor::Alerts::Persistance::NameAlreadyExists
-      name_already_exists_response
+      if Motor::Alerts::Persistance.name_already_exists?(@alert)
+        name_already_exists_response
+      else
+        ApplicationRecord.transaction { @alert.save! }
+        Motor::Alerts::ScheduledAlertsCache.clear
+        Motor::Configs::WriteToFile.call
+
+        render json: { data: Motor::ApiQuery::BuildJson.call(@alert, params) }
+      end
     rescue Motor::Alerts::Persistance::InvalidInterval
       invalid_interval_response
     end
@@ -31,6 +34,7 @@ module Motor
     def update
       Motor::Alerts::Persistance.update_from_params!(@alert, alert_params)
       Motor::Alerts::ScheduledAlertsCache.clear
+      Motor::Configs::WriteToFile.call
 
       render json: { data: Motor::ApiQuery::BuildJson.call(@alert, params) }
     rescue Motor::Alerts::Persistance::NameAlreadyExists
@@ -42,6 +46,8 @@ module Motor
     def destroy
       @alert.update!(deleted_at: Time.current)
 
+      Motor::Configs::WriteToFile.call
+
       head :ok
     end
 

data/app/controllers/motor/configs_controller.rb

@@ -17,6 +17,7 @@ module Motor
         end
 
       @config.save!
+      Motor::Configs::WriteToFile.call
 
       render json: { data: Motor::ApiQuery::BuildJson.call(@config, params) }
     rescue ActiveRecord::RecordNotUnique

data/app/controllers/motor/dashboards_controller.rb

@@ -22,6 +22,7 @@ module Motor
         render json: { errors: [{ source: 'title', detail: 'Title already exists' }] }, status: :unprocessable_entity
       else
         ApplicationRecord.transaction { @dashboard.save! }
+        Motor::Configs::WriteToFile.call
 
         render json: { data: Motor::ApiQuery::BuildJson.call(@dashboard, params) }
       end
@@ -31,6 +32,7 @@ module Motor
 
     def update
       Motor::Dashboards::Persistance.update_from_params!(@dashboard, dashboard_params)
+      Motor::Configs::WriteToFile.call
 
       render json: { data: Motor::ApiQuery::BuildJson.call(@dashboard, params) }
     rescue Motor::Dashboards::Persistance::TitleAlreadyExists
@@ -40,6 +42,8 @@ module Motor
     def destroy
       @dashboard.update!(deleted_at: Time.current)
 
+      Motor::Configs::WriteToFile.call
+
       head :ok
     end
 

data/app/controllers/motor/forms_controller.rb

@@ -22,6 +22,7 @@ module Motor
         render json: { errors: [{ source: 'name', detail: 'Name already exists' }] }, status: :unprocessable_entity
       else
         ApplicationRecord.transaction { @form.save! }
+        Motor::Configs::WriteToFile.call
 
         render json: { data: Motor::ApiQuery::BuildJson.call(@form, params) }
       end
@@ -31,6 +32,7 @@ module Motor
 
     def update
       Motor::Forms::Persistance.update_from_params!(@form, form_params)
+      Motor::Configs::WriteToFile.call
 
       render json: { data: Motor::ApiQuery::BuildJson.call(@form, params) }
     rescue Motor::Forms::Persistance::NameAlreadyExists
@@ -40,6 +42,8 @@ module Motor
     def destroy
       @form.update!(deleted_at: Time.current)
 
+      Motor::Configs::WriteToFile.call
+
       head :ok
     end
 

data/app/controllers/motor/queries_controller.rb

@@ -22,6 +22,7 @@ module Motor
         render json: { errors: [{ source: 'name', detail: 'Name already exists' }] }, status: :unprocessable_entity
       else
         ApplicationRecord.transaction { @query.save! }
+        Motor::Configs::WriteToFile.call
 
         render json: { data: Motor::ApiQuery::BuildJson.call(@query, params) }
       end
@@ -31,6 +32,7 @@ module Motor
 
     def update
       Motor::Queries::Persistance.update_from_params!(@query, query_params)
+      Motor::Configs::WriteToFile.call
 
       render json: { data: Motor::ApiQuery::BuildJson.call(@query, params) }
     rescue Motor::Queries::Persistance::NameAlreadyExists
@@ -40,6 +42,8 @@ module Motor
     def destroy
       @query.update!(deleted_at: Time.current)
 
+      Motor::Configs::WriteToFile.call
+
       head :ok
     end
 

data/app/controllers/motor/resources_controller.rb

@@ -12,6 +12,7 @@ module Motor
 
     def create
       Motor::BuildSchema::PersistResourceConfigs.call(@resource)
+      Motor::Configs::WriteToFile.call
 
       render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params) }
     end

data/app/controllers/motor/ui_controller.rb

@@ -7,12 +7,16 @@ module Motor
     def index
       Motor.reload! if Motor.development?
 
+      Motor::Configs::SyncFromFile.call
+
       render :show
     end
 
     def show
       Motor.reload! if Motor.development?
 
+      Motor::Configs::SyncFromFile.call
+
       render :show
     end
   end

data/app/views/motor/ui/show.html.erb

@@ -1 +1 @@
-<%= raw(Motor::UiConfigs.app_tag) %>
+<%= raw(Motor::Configs::BuildUiAppTag.call) %>

data/lib/motor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/timer_task'
 require 'cancancan'
 require 'ar_lazy_preload'
 require 'js_regex'
@@ -7,6 +9,9 @@ require 'fugit'
 require 'csv'
 require 'active_record/filter'
 require 'audited'
+require 'uri'
+require 'net/http'
+require 'net/https'
 
 module Motor
   PATH = Pathname.new(__dir__)
@@ -18,7 +23,8 @@ module Motor
       Dir[PATH.join('./motor/**/*.rb')].each do |f|
         next if f.ends_with?('alerts/scheduler.rb')
         next if f.ends_with?('alerts/scheduled_alerts_cache.rb')
-        next if f.ends_with?('ui_configs.rb')
+        next if f.ends_with?('configs/load_from_cache.rb')
+        next if f.ends_with?('configs/sync_from_file.rb')
 
         load f
       end
@@ -50,10 +56,12 @@ require 'motor/assets'
 require 'motor/build_schema'
 require 'motor/api_query'
 require 'motor/tags'
-require 'motor/ui_configs'
+require 'motor/configs'
 require 'motor/queries'
 require 'motor/dashboards'
 require 'motor/forms'
 require 'motor/alerts'
 require 'motor/hash_serializer'
 require 'motor/active_record_utils'
+require 'motor/net_http_utils'
+require 'motor/railtie'

data/lib/motor/admin.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'motor/configs/sync_middleware'
+
 module Motor
   class Admin < ::Rails::Engine
     initializer 'motor.startup_message' do
@@ -28,6 +30,12 @@ module Motor
       end
     end
 
+    initializer 'motor.configs.sync_middleware' do
+      if Motor::Configs::SyncMiddleware::ACCESS_KEY.present?
+        Rails.application.config.middleware.insert_before(0, Motor::Configs::SyncMiddleware)
+      end
+    end
+
     initializer 'motor.filter_params' do
       Rails.application.config.filter_parameters += %i[io]
     end

data/lib/motor/alerts/persistance.rb

@@ -44,6 +44,8 @@ module Motor
       end
 
       def update_from_params!(alert, params)
+        tag_ids = alert.tags.ids
+
         alert = assign_attributes(alert, params)
 
         raise NameAlreadyExists if name_already_exists?(alert)
@@ -53,7 +55,7 @@ module Motor
           alert.save!
         end
 
-        alert.tags.reload
+        alert.touch if tag_ids.sort != alert.tags.reload.ids.sort && params[:updated_at].blank?
 
         alert
       rescue ActiveRecord::RecordNotUnique
@@ -63,6 +65,7 @@ module Motor
       def assign_attributes(alert, params)
         alert.assign_attributes(params.slice(*ALERT_ATTRIBUTES))
         alert.preferences[:interval] = normalize_interval(alert.preferences[:interval])
+        alert.updated_at = [params[:updated_at], Time.current].min if params[:updated_at].present?
 
         Motor::Tags.assign_tags(alert, params[:tags])
       end

data/lib/motor/alerts/scheduler.rb

@@ -22,7 +22,7 @@ module Motor
             Motor::AlertSendingJob.perform_later(alert).job_id
           end
         rescue StandardError => e
-          Rials.logger.error(e)
+          Rails.logger.error(e)
         end
       end
     end

data/lib/motor/build_schema.rb

@@ -58,11 +58,11 @@ module Motor
 
     module_function
 
-    def call
+    def call(cache_keys = {})
       schema = LoadFromRails.call
-      schema = MergeSchemaConfigs.call(schema)
+      schema = MergeSchemaConfigs.call(schema, cache_keys)
 
-      ReorderSchema.call(schema)
+      ReorderSchema.call(schema, cache_keys)
     end
   end
 end

data/lib/motor/build_schema/merge_schema_configs.rb

@@ -12,9 +12,10 @@ module Motor
       module_function
 
       # @param schema [Array<HashWithIndifferentAccess>]
+      # @param cache_keys [Hash]
       # @return [Array<HashWithIndifferentAccess>]
-      def call(schema)
-        configs = load_configs
+      def call(schema, cache_keys = {})
+        configs = load_configs(cache_keys)
 
         schema.map do |model|
           merge_model(model, configs.fetch(model[:name], {}))
@@ -120,9 +121,12 @@ module Motor
         end.compact
       end
 
+      # @param cache_keys [Hash]
       # @return [HashWithIndifferentAccess<String, HashWithIndifferentAccess>]
-      def load_configs
-        Motor::Resource.all.each_with_object(HashWithIndifferentAccess.new) do |resource, acc|
+      def load_configs(cache_keys)
+        resources = Motor::Configs::LoadFromCache.load_resources(cache_key: cache_keys[:resources])
+
+        resources.each_with_object(HashWithIndifferentAccess.new) do |resource, acc|
           acc[resource.name] = resource.preferences
         end
       end

data/lib/motor/build_schema/reorder_schema.rb

@@ -16,10 +16,11 @@ module Motor
 
     module_function
 
+    # @param cache_keys [Hash]
     # @param schema [Array<HashWithIndifferentAccess>]
     # @return [Array<HashWithIndifferentAccess>]
-    def call(schema)
-      configs = load_configs
+    def call(schema, cache_keys = {})
+      configs = load_configs(cache_keys)
 
       schema = sort_by_name(schema, configs['resources.order'])
 
@@ -64,6 +65,8 @@ module Motor
       end
     end
 
+    # @param columns [Array<HashWithIndifferentAccess>]
+    # @return [Array<HashWithIndifferentAccess>]
     def sort_columns(columns)
       columns.each_with_object([]) do |column, acc|
         weight = COLUMNS_DEFAULT_ORDER_WEIGHTS.fetch(column[:name], COLUMNS_DEFAULT_ORDER_WEIGHT)
@@ -72,9 +75,12 @@ module Motor
       end.flatten.compact
     end
 
+    # @param cache_keys [Hash]
     # @return [Hash<String, HashWithIndifferentAccess>]
-    def load_configs
-      Motor::Config.all.each_with_object({}) do |config, acc|
+    def load_configs(cache_keys = {})
+      configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_keys[:configs])
+
+      configs.each_with_object({}) do |config, acc|
         acc[config.key] = config.value
       end
     end

data/lib/motor/configs.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    FILE_PATH = 'config/motor.yml'
+    SYNC_API_PATH = '/motor_configs_sync'
+  end
+end
+
+require_relative './configs/load_from_cache'
+require_relative './configs/build_ui_app_tag'
+require_relative './configs/build_configs_hash'
+require_relative './configs/write_to_file'
+require_relative './configs/sync_from_hash'
+require_relative './configs/sync_from_file'
+require_relative './configs/sync_with_remote'

data/lib/motor/configs/build_configs_hash.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module BuildConfigsHash
+      module_function
+
+      def call
+        cache_keys = LoadFromCache.load_cache_keys
+
+        normalize_hash(
+          app_version: Motor::VERSION,
+          file_version: cache_keys.values.max.to_time,
+          resources: build_resources_hash(cache_keys[:resources]),
+          configs: build_configs_hash(cache_keys[:configs]),
+          queries: build_queries_hash(cache_keys[:queries]),
+          dashboards: build_dashboards_hash(cache_keys[:dashboards]),
+          forms: build_forms_hash(cache_keys[:forms]),
+          alerts: build_alerts_hash(cache_keys[:alerts])
+        )
+      end
+
+      def build_queries_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_queries(cache_key: cache_key).sort_by(&:id).map do |query|
+          query.slice(%i[id name sql_body description preferences])
+               .merge(tags: query.tags.map(&:name), updated_at: query.updated_at.to_time)
+        end
+      end
+
+      def build_dashboards_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_dashboards(cache_key: cache_key).sort_by(&:id).map do |dashboard|
+          dashboard.slice(%i[id title description preferences])
+                   .merge(tags: dashboard.tags.map(&:name), updated_at: dashboard.updated_at.to_time)
+        end
+      end
+
+      def build_alerts_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_alerts(cache_key: cache_key).sort_by(&:id).map do |alert|
+          alert.slice(%i[id name query_id to_emails is_enabled description preferences])
+               .merge(tags: alert.tags.map(&:name), updated_at: alert.updated_at.to_time)
+        end
+      end
+
+      def build_forms_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_forms(cache_key: cache_key).sort_by(&:id).map do |form|
+          form.slice(%i[id name http_method api_path description preferences])
+              .merge(tags: form.tags.map(&:name), updated_at: form.updated_at.to_time)
+        end
+      end
+
+      def build_configs_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_configs(cache_key: cache_key).sort_by(&:key).map do |config|
+          {
+            key: config.key,
+            value: config.value,
+            updated_at: config.updated_at.to_time
+          }
+        end
+      end
+
+      def build_resources_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_resources(cache_key: cache_key).sort_by(&:name).map do |resource|
+          {
+            name: resource.name,
+            preferences: resource.preferences,
+            updated_at: resource.updated_at.to_time
+          }
+        end
+      end
+
+      def normalize_hash(value)
+        case value
+        when Hash, HashWithIndifferentAccess
+          value.to_h.stringify_keys.transform_values { |v| normalize_hash(v) }
+        when Array
+          value.map { |e| normalize_hash(e) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/motor/configs/build_ui_app_tag.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module BuildUiAppTag
+      CACHE_STORE =
+        if Motor.development?
+          ActiveSupport::Cache::NullStore.new
+        else
+          ActiveSupport::Cache::MemoryStore.new(size: 5.megabytes)
+        end
+
+      module_function
+
+      def call
+        cache_keys = LoadFromCache.load_cache_keys
+
+        CACHE_STORE.fetch(cache_keys.hash) do
+          CACHE_STORE.clear
+
+          Motor::ApplicationController.helpers.content_tag(
+            :div, '', id: 'app', data: build_data(cache_keys)
+          )
+        end
+      end
+
+      # @return [Hash]
+      def build_data(cache_keys = {})
+        {
+          base_path: Motor::Admin.routes.url_helpers.motor_path,
+          schema: Motor::BuildSchema.call(cache_keys),
+          header_links: header_links_data_hash(cache_keys[:configs]),
+          queries: queries_data_hash(cache_keys[:queries]),
+          dashboards: dashboards_data_hash(cache_keys[:dashboards]),
+          alerts: alerts_data_hash(cache_keys[:alerts]),
+          forms: forms_data_hash(cache_keys[:forms])
+        }
+      end
+
+      def header_links_data_hash(cache_key = nil)
+        configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_key)
+
+        configs.find { |c| c.key == 'header.links' }&.value || []
+      end
+
+      def queries_data_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_queries(cache_key: cache_key)
+                                     .as_json(only: %i[id name updated_at],
+                                              include: { tags: { only: %i[id name] } })
+      end
+
+      def dashboards_data_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_dashboards(cache_key: cache_key)
+                                     .as_json(only: %i[id title updated_at],
+                                              include: { tags: { only: %i[id name] } })
+      end
+
+      def alerts_data_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_alerts(cache_key: cache_key)
+                                     .as_json(only: %i[id name is_enabled updated_at],
+                                              include: { tags: { only: %i[id name] } })
+      end
+
+      def forms_data_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_forms(cache_key: cache_key)
+                                     .as_json(only: %i[id name updated_at],
+                                              include: { tags: { only: %i[id name] } })
+      end
+    end
+  end
+end

data/lib/motor/configs/load_from_cache.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module LoadFromCache
+      CACHE_STORE = ActiveSupport::Cache::MemoryStore.new(size: 10.megabytes)
+
+      module_function
+
+      def call
+        cache_keys = load_cache_keys
+
+        {
+          configs: load_configs(cache_key: cache_keys[:configs]),
+          resources: load_resources(cache_key: cache_keys[:resources]),
+          queries: load_queries(cache_key: cache_keys[:queries]),
+          dashboards: load_dashboards(cache_key: cache_keys[:dashboards]),
+          alerts: load_alerts(cache_key: cache_keys[:alerts]),
+          forms: load_forms(cache_key: cache_keys[:forms])
+        }
+      end
+
+      def load_configs(cache_key: nil)
+        maybe_fetch_from_cache('configs', cache_key) do
+          Motor::Config.all.load
+        end
+      end
+
+      def load_resources(cache_key: nil)
+        maybe_fetch_from_cache('resources', cache_key) do
+          Motor::Resource.all.load
+        end
+      end
+
+      def load_queries(cache_key: nil)
+        maybe_fetch_from_cache('queries', cache_key) do
+          Motor::Query.all.active.preload(:tags).load
+        end
+      end
+
+      def load_dashboards(cache_key: nil)
+        maybe_fetch_from_cache('dashboards', cache_key) do
+          Motor::Dashboard.all.active.preload(:tags).load
+        end
+      end
+
+      def load_alerts(cache_key: nil)
+        maybe_fetch_from_cache('alerts', cache_key) do
+          Motor::Alert.all.active.preload(:tags).load
+        end
+      end
+
+      def load_forms(cache_key: nil)
+        maybe_fetch_from_cache('forms', cache_key) do
+          Motor::Form.all.active.preload(:tags).load
+        end
+      end
+
+      def maybe_fetch_from_cache(type, cache_key, &block)
+        return block.call unless cache_key
+
+        CACHE_STORE.fetch(type + cache_key.to_s, &block)
+      end
+
+      def load_cache_keys
+        ActiveRecord::Base.connection.execute(
+          "(#{
+            [
+              Motor::Config.select("'configs', MAX(updated_at)").to_sql,
+              Motor::Resource.select("'resources', MAX(updated_at)").to_sql,
+              Motor::Dashboard.select("'dashboards', MAX(updated_at)").to_sql,
+              Motor::Alert.select("'alerts', MAX(updated_at)").to_sql,
+              Motor::Query.select("'queries', MAX(updated_at)").to_sql,
+              Motor::Form.select("'forms', MAX(updated_at)").to_sql
+            ].join(') UNION (')
+          })"
+        ).to_a.map(&:values).to_h.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/motor/configs/sync_from_file.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module SyncFromFile
+      FILE_PATH = Motor::Configs::FILE_PATH
+      MUTEXT = Mutex.new
+      FILE_TIMESTAMPS_STORE = ActiveSupport::Cache::MemoryStore.new(size: 1.megabyte)
+
+      module_function
+
+      def call
+        MUTEXT.synchronize do
+          file = Rails.root.join(FILE_PATH)
+
+          file_timestamp =
+            begin
+              file.ctime
+            rescue Errno::ENOENT
+              nil
+            end
+
+          next unless file_timestamp
+
+          FILE_TIMESTAMPS_STORE.fetch(file_timestamp.to_s) do
+            Motor::Configs::SyncFromHash.call(
+              YAML.safe_load(file.read, permitted_classes: [Time, Date])
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/motor/configs/sync_from_hash.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module SyncFromHash
+      module_function
+
+      def call(configs_hash)
+        configs_hash = configs_hash.with_indifferent_access
+
+        Motor::ApplicationRecord.transaction do
+          sync_queries(configs_hash)
+          sync_alerts(configs_hash)
+          sync_dashboards(configs_hash)
+          sync_forms(configs_hash)
+          sync_configs(configs_hash)
+          sync_resources(configs_hash)
+        end
+      end
+
+      def sync_queries(configs_hash)
+        sync_taggable(
+          Motor::Configs::LoadFromCache.load_queries,
+          configs_hash[:queries],
+          configs_hash[:file_version],
+          Motor::Queries::Persistance.method(:update_from_params!)
+        )
+      end
+
+      def sync_alerts(configs_hash)
+        sync_taggable(
+          Motor::Configs::LoadFromCache.load_alerts,
+          configs_hash[:alerts],
+          configs_hash[:file_version],
+          Motor::Alerts::Persistance.method(:update_from_params!)
+        )
+      end
+
+      def sync_forms(configs_hash)
+        sync_taggable(
+          Motor::Configs::LoadFromCache.load_forms,
+          configs_hash[:forms],
+          configs_hash[:file_version],
+          Motor::Forms::Persistance.method(:update_from_params!)
+        )
+      end
+
+      def sync_dashboards(configs_hash)
+        sync_taggable(
+          Motor::Configs::LoadFromCache.load_dashboards,
+          configs_hash[:dashboards],
+          configs_hash[:file_version],
+          Motor::Dashboards::Persistance.method(:update_from_params!)
+        )
+      end
+
+      def sync_configs(configs_hash)
+        configs_index = Motor::Configs::LoadFromCache.load_configs.index_by(&:key)
+
+        configs_hash[:configs].each do |attrs|
+          record = configs_index[attrs[:key]] || Motor::Config.new
+
+          next if record.updated_at && attrs[:updated_at] <= record.updated_at
+
+          record.update!(attrs)
+        end
+      end
+
+      def sync_resources(configs_hash)
+        resources_index = Motor::Configs::LoadFromCache.load_resources.index_by(&:name)
+
+        configs_hash[:resources].each do |attrs|
+          record = resources_index[attrs[:name]] || Motor::Resource.new
+
+          next if record.updated_at && attrs[:updated_at] <= record.updated_at
+
+          record.update!(attrs)
+        end
+      end
+
+      def sync_taggable(records, config_items, configs_timestamp, update_proc)
+        processed_records, create_items = update_taggable_items(records, config_items, update_proc)
+
+        create_taggable_items(create_items, records.klass, update_proc)
+
+        archive_taggable_items(records - processed_records, configs_timestamp)
+
+        ActiveRecord::Base.connection.reset_pk_sequence!(records.klass.table_name)
+      end
+
+      def update_taggable_items(records, config_items, update_proc)
+        record_ids_hash = records.index_by(&:id)
+
+        config_items.each_with_object([[], []]) do |attrs, (processed_acc, create_acc)|
+          record = record_ids_hash[attrs[:id]]
+
+          next create_acc << attrs unless record
+
+          processed_acc << record if record
+
+          next if record.updated_at >= attrs[:updated_at]
+
+          update_proc.call(record, attrs)
+        end
+      end
+
+      def create_taggable_items(create_items, records_class, update_proc)
+        create_items.each do |attrs|
+          record = records_class.find_or_initialize_by(id: attrs[:id]).tap { |e| e.deleted_at = nil }
+
+          update_proc.call(record, attrs)
+        end
+      end
+
+      def archive_taggable_items(records_to_remove, configs_timestamp)
+        records_to_remove.each do |record|
+          next if record.updated_at > configs_timestamp
+
+          record.update!(deleted_at: Time.current) if record.deleted_at.blank?
+        end
+      end
+    end
+  end
+end

data/lib/motor/configs/sync_middleware.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    class SyncMiddleware
+      ACCESS_KEY = ENV.fetch('MOTOR_SYNC_API_KEY', '')
+
+      KeyNotSpecified = Class.new(StandardError)
+      NotAuthenticated = Class.new(StandardError)
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env['PATH_INFO'] == Motor::Configs::SYNC_API_PATH
+          authenticate!(env['QUERY_STRING'])
+
+          case env['REQUEST_METHOD']
+          when 'GET'
+            respond_with_configs
+          when 'POST'
+            sync_configs(env['rack.input'].read)
+          else
+            @app.call(env)
+          end
+        else
+          @app.call(env)
+        end
+      rescue NotAuthenticated
+        [403, {}, ['Invalid synchronization API key']]
+      rescue KeyNotSpecified
+        [404, {}, ['Set `MOTOR_SYNC_API_KEY` environment variable in order to sync configs']]
+      end
+
+      private
+
+      def authenticate!(query_string)
+        raise KeyNotSpecified if ACCESS_KEY.blank?
+        raise NotAuthenticated if query_string.blank?
+
+        is_token_valid =
+          ActiveSupport::SecurityUtils.secure_compare(
+            Digest::SHA256.hexdigest(query_string),
+            Digest::SHA256.hexdigest("token=#{ACCESS_KEY}")
+          )
+
+        raise NotAuthenticated unless is_token_valid
+      end
+
+      def respond_with_configs
+        [
+          200,
+          { 'Content-Type' => 'application/json' },
+          [Motor::Configs::BuildConfigsHash.call.to_json]
+        ]
+      rescue StandardError => e
+        [500, {}, [e.message]]
+      end
+
+      def sync_configs(body)
+        configs_hash = JSON.parse(body)
+
+        Motor::Configs::SyncFromHash.call(configs_hash)
+
+        [200, {}, []]
+      rescue StandardError => e
+        [500, {}, [e.message]]
+      end
+    end
+  end
+end

data/lib/motor/configs/sync_with_remote.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module SyncWithRemote
+      UnableToSync = Class.new(StandardError)
+      ApiNotFound = Class.new(StandardError)
+
+      module_function
+
+      def call(remote_url, api_key)
+        url = remote_url.sub(%r{/\z}, '') + Motor::Configs::SYNC_API_PATH
+
+        sync_from_remote!(url, api_key)
+        sync_to_remote!(url, api_key)
+      end
+
+      def sync_from_remote!(remote_url, api_key)
+        response = Motor::NetHttpUtils.get(remote_url, { token: api_key })
+
+        raise ApiNotFound if response.is_a?(Net::HTTPNotFound)
+        raise UnableToSync, [response.message, response.body].join(': ') unless response.is_a?(Net::HTTPSuccess)
+
+        configs_hash = JSON.parse(response.body)
+
+        Motor::Configs::SyncFromHash.call(configs_hash)
+      end
+
+      def sync_to_remote!(remote_url, api_key)
+        configs_hash = Motor::Configs::BuildConfigsHash.call
+
+        response = Motor::NetHttpUtils.post(remote_url, { token: api_key }, configs_hash.to_json)
+
+        raise ApiNotFound if response.is_a?(Net::HTTPNotFound)
+        raise UnableToSync, [response.message, response.body].join(': ') unless response.is_a?(Net::HTTPSuccess)
+      end
+    end
+  end
+end

data/lib/motor/configs/write_to_file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module WriteToFile
+      THREAD_POOL = Concurrent::FixedThreadPool.new(1)
+      FILE_PATH = Motor::Configs::FILE_PATH
+
+      module_function
+
+      def call
+        return if THREAD_POOL.queue_length.positive?
+
+        THREAD_POOL.post do
+          ActiveRecord::Base.logger.silence do
+            write_with_lock
+          end
+        rescue StandardError => e
+          Rails.logger.error(e)
+        end
+      end
+
+      def write_with_lock
+        File.open(Rails.root.join(FILE_PATH), 'w') do |file|
+          file.flock(File::LOCK_EX)
+
+          YAML.dump(Motor::Configs::BuildConfigsHash.call, file)
+
+          file.flock(File::LOCK_UN)
+
+          file
+        end.close
+      end
+    end
+  end
+end

data/lib/motor/dashboards/persistance.rb

@@ -30,6 +30,8 @@ module Motor
       end
 
       def update_from_params!(dashboard, params)
+        tag_ids = dashboard.tags.ids
+
         dashboard = assign_attributes(dashboard, params)
 
         raise TitleAlreadyExists if title_already_exists?(dashboard)
@@ -38,7 +40,7 @@ module Motor
           dashboard.save!
         end
 
-        dashboard.tags.reload
+        dashboard.touch if tag_ids.sort != dashboard.tags.reload.ids.sort && params[:updated_at].blank?
 
         dashboard
       rescue ActiveRecord::RecordNotUnique
@@ -47,6 +49,7 @@ module Motor
 
       def assign_attributes(dashboard, params)
         dashboard.assign_attributes(params.slice(:title, :description, :preferences))
+        dashboard.updated_at = [params[:updated_at], Time.current].min if params[:updated_at].present?
 
         Motor::Tags.assign_tags(dashboard, params[:tags])
       end

data/lib/motor/forms/persistance.rb

@@ -30,6 +30,8 @@ module Motor
       end
 
       def update_from_params!(form, params)
+        tag_ids = form.tags.ids
+
         form = assign_attributes(form, params)
 
         raise NameAlreadyExists if name_already_exists?(form)
@@ -38,7 +40,7 @@ module Motor
           form.save!
         end
 
-        form.tags.reload
+        form.touch if tag_ids.sort != form.tags.reload.ids.sort && params[:updated_at].blank?
 
         form
       rescue ActiveRecord::RecordNotUnique
@@ -47,6 +49,7 @@ module Motor
 
       def assign_attributes(form, params)
         form.assign_attributes(params.slice(:name, :description, :api_path, :http_method, :preferences))
+        form.updated_at = [params[:updated_at], Time.current].min if params[:updated_at].present?
 
         Motor::Tags.assign_tags(form, params[:tags])
       end

data/lib/motor/net_http_utils.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Motor
+  module NetHttpUtils
+    module_function
+
+    def get(url, params = {})
+      request = build_request(Net::HTTP::Get, url, params, nil)
+
+      execute_request(request)
+    end
+
+    def post(url, params = {}, body = '')
+      request = build_request(Net::HTTP::Post, url, params, body)
+
+      execute_request(request)
+    end
+
+    def build_request(method_class, url, params, body)
+      uri = URI(url)
+      uri.query = params.to_query
+
+      request = method_class.new(uri)
+      request.body = body if body.present?
+
+      request
+    end
+
+    def execute_request(request)
+      uri = request.uri
+
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.port == 443) do |http|
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/motor/queries/persistance.rb

@@ -30,6 +30,8 @@ module Motor
       end
 
       def update_from_params!(query, params)
+        tag_ids = query.tags.ids
+
         query = assign_attributes(query, params)
 
         raise NameAlreadyExists if name_already_exists?(query)
@@ -38,7 +40,7 @@ module Motor
           query.save!
         end
 
-        query.tags.reload
+        query.touch if tag_ids.sort != query.tags.reload.ids.sort && params[:updated_at].blank?
 
         query
       rescue ActiveRecord::RecordNotUnique
@@ -47,6 +49,7 @@ module Motor
 
       def assign_attributes(query, params)
         query.assign_attributes(params.slice(:name, :description, :sql_body, :preferences))
+        query.updated_at = [params[:updated_at], Time.current].min if params[:updated_at].present?
 
         Motor::Tags.assign_tags(query, params[:tags])
       end

data/lib/motor/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Motor
+  class Railtie < Rails::Railtie
+    railtie_name :motor_admin
+
+    rake_tasks do
+      Dir[Motor::PATH.join('./motor/tasks/**/*.rake')].each { |f| load f }
+    end
+  end
+end

data/lib/motor/tasks/motor.rake

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+namespace :motor do
+  desc 'Update configs/motor.yml file'
+
+  task dump: :environment do
+    Motor::Configs::WriteToFile.write_with_lock
+
+    puts '✅ configs/motor.yml has been updated'
+  end
+
+  desc 'Synchronize configs with remote application'
+
+  task sync: :environment do
+    remote_url = ENV['MOTOR_SYNC_REMOTE_URL']
+    api_key = ENV['MOTOR_SYNC_API_KEY']
+
+    raise 'Specify target app url using `MOTOR_SYNC_REMOTE_URL` env variable' if remote_url.blank?
+    raise 'Specify sync api key using `MOTOR_SYNC_API_KEY` env variable' if api_key.blank?
+
+    Motor::Configs::SyncWithRemote.call(remote_url, api_key)
+    Motor::Configs::WriteToFile.write_with_lock
+
+    puts "✅ Motor Admin configurations have been synced with #{remote_url}"
+  rescue Motor::Configs::SyncWithRemote::ApiNotFound
+    puts '⚠️  Synchronization failed: you need to specify `MOTOR_SYNC_API_KEY` ' \
+         'env variable in your remote app in order to enable this feature'
+  end
+end

data/lib/motor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Motor
-  VERSION = '0.1.37'
+  VERSION = '0.1.39'
 end

data/ui/dist/manifest.json

@@ -5,9 +5,9 @@
   "fonts/ionicons.ttf?v=3.0.0-alpha.3": "fonts/ionicons.ttf",
   "fonts/ionicons.woff2?v=3.0.0-alpha.3": "fonts/ionicons.woff2",
   "fonts/ionicons.woff?v=3.0.0-alpha.3": "fonts/ionicons.woff",
-  "main-358ea31cd7020f915067.css.gz": "main-358ea31cd7020f915067.css.gz",
-  "main-358ea31cd7020f915067.js.LICENSE.txt": "main-358ea31cd7020f915067.js.LICENSE.txt",
-  "main-358ea31cd7020f915067.js.gz": "main-358ea31cd7020f915067.js.gz",
-  "main.css": "main-358ea31cd7020f915067.css",
-  "main.js": "main-358ea31cd7020f915067.js"
+  "main-e443f49b386b119ff25a.css.gz": "main-e443f49b386b119ff25a.css.gz",
+  "main-e443f49b386b119ff25a.js.LICENSE.txt": "main-e443f49b386b119ff25a.js.LICENSE.txt",
+  "main-e443f49b386b119ff25a.js.gz": "main-e443f49b386b119ff25a.js.gz",
+  "main.css": "main-e443f49b386b119ff25a.css",
+  "main.js": "main-e443f49b386b119ff25a.js"
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motor-admin
 version: !ruby/object:Gem::Version
-  version: 0.1.37
+  version: 0.1.39
 platform: ruby
 authors:
 - Pete Matsyburka
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-13 00:00:00.000000000 Z
+date: 2021-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord-filter
@@ -217,22 +217,33 @@ files:
 - lib/motor/build_schema/persist_resource_configs.rb
 - lib/motor/build_schema/reorder_schema.rb
 - lib/motor/build_schema/utils.rb
+- lib/motor/configs.rb
+- lib/motor/configs/build_configs_hash.rb
+- lib/motor/configs/build_ui_app_tag.rb
+- lib/motor/configs/load_from_cache.rb
+- lib/motor/configs/sync_from_file.rb
+- lib/motor/configs/sync_from_hash.rb
+- lib/motor/configs/sync_middleware.rb
+- lib/motor/configs/sync_with_remote.rb
+- lib/motor/configs/write_to_file.rb
 - lib/motor/dashboards.rb
 - lib/motor/dashboards/persistance.rb
 - lib/motor/forms.rb
 - lib/motor/forms/persistance.rb
 - lib/motor/hash_serializer.rb
+- lib/motor/net_http_utils.rb
 - lib/motor/queries.rb
 - lib/motor/queries/persistance.rb
 - lib/motor/queries/postgresql_exec_query.rb
 - lib/motor/queries/render_sql_template.rb
 - lib/motor/queries/run_query.rb
+- lib/motor/railtie.rb
 - lib/motor/tags.rb
-- lib/motor/ui_configs.rb
+- lib/motor/tasks/motor.rake
 - lib/motor/version.rb
 - ui/dist/fonts/ionicons.woff2
-- ui/dist/main-358ea31cd7020f915067.css.gz
-- ui/dist/main-358ea31cd7020f915067.js.gz
+- ui/dist/main-e443f49b386b119ff25a.css.gz
+- ui/dist/main-e443f49b386b119ff25a.js.gz
 - ui/dist/manifest.json
 homepage:
 licenses:

data/lib/motor/ui_configs.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Motor
-  module UiConfigs
-    CACHE_STORE =
-      if Motor.development?
-        ActiveSupport::Cache::NullStore.new
-      else
-        ActiveSupport::Cache::MemoryStore.new(size: 5.megabytes)
-      end
-
-    module_function
-
-    # @return [String]
-    def app_tag
-      CACHE_STORE.fetch(cache_key) do
-        CACHE_STORE.clear
-
-        Motor::ApplicationController.helpers.content_tag(
-          :div, '', id: 'app', data: ui_data
-        )
-      end
-    end
-
-    # @return [Hash]
-    def ui_data
-      {
-        base_path: Motor::Admin.routes.url_helpers.motor_path,
-        schema: Motor::BuildSchema.call,
-        header_links: header_links_data_hash,
-        queries: queries_data_hash,
-        dashboards: dashboards_data_hash,
-        alerts: alerts_data_hash,
-        forms: forms_data_hash
-      }
-    end
-
-    def header_links_data_hash
-      Motor::Config.find_by(key: 'header.links')&.value || []
-    end
-
-    def queries_data_hash
-      Motor::Query.all.active.preload(:tags)
-                  .as_json(only: %i[id name updated_at],
-                           include: { tags: { only: %i[id name] } })
-    end
-
-    def dashboards_data_hash
-      Motor::Dashboard.all.active.preload(:tags)
-                      .as_json(only: %i[id title updated_at],
-                               include: { tags: { only: %i[id name] } })
-    end
-
-    def alerts_data_hash
-      Motor::Alert.all.active.preload(:tags)
-                  .as_json(only: %i[id name is_enabled updated_at],
-                           include: { tags: { only: %i[id name] } })
-    end
-
-    def forms_data_hash
-      Motor::Form.all.active.preload(:tags)
-                 .as_json(only: %i[id name updated_at],
-                          include: { tags: { only: %i[id name] } })
-    end
-
-    # @return [String]
-    def cache_key
-      ActiveRecord::Base.connection.execute(
-        "(#{
-          [
-            Motor::Config.select('MAX(updated_at)').to_sql,
-            Motor::Resource.select('MAX(updated_at)').to_sql,
-            Motor::Dashboard.select('MAX(updated_at)').to_sql,
-            Motor::Alert.select('MAX(updated_at)').to_sql,
-            Motor::Query.select('MAX(updated_at)').to_sql,
-            Motor::Form.select('MAX(updated_at)').to_sql
-          ].join(') UNION (')
-        })"
-      ).to_a.hash.to_s
-    end
-  end
-end