logux_rails 0.1.0

data/lib/logux/action_caller.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Logux
+  class ActionCaller
+    attr_reader :action, :meta
+
+    delegate :logger, to: :Logux
+
+    def initialize(action:, meta:)
+      @action = action
+      @meta = meta
+    end
+
+    def call!
+      Logux::Model::UpdatesDeprecator.watch(level: :error) do
+        logger.debug(
+          "Searching action for Logux action: #{action}, meta: #{meta}"
+        )
+        format(action_controller.public_send(action.action_type))
+      end
+    rescue Logux::UnknownActionError, Logux::UnknownChannelError => e
+      logger.warn(e)
+      format(nil)
+    end
+
+    private
+
+    def format(response)
+      return response if response.is_a?(Logux::Response)
+
+      Logux::Response.new(:processed, action: action, meta: meta)
+    end
+
+    def class_finder
+      @class_finder ||= Logux::ClassFinder.new(action: action, meta: meta)
+    end
+
+    def action_controller
+      class_finder.find_action_class.new(action: action, meta: meta)
+    end
+  end
+end

data/lib/logux/action_controller.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Logux
+  class ActionController < Logux::BaseController
+  end
+end

data/lib/logux/actions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Logux
+  class Actions < ::ActionController::Parameters
+    def action_name
+      type&.split('/')&.dig(0)
+    end
+
+    def action_type
+      type&.split('/')&.last
+    end
+
+    def channel_name
+      channel&.split('/')&.dig(0)
+    end
+
+    def channel_id
+      channel&.split('/')&.last
+    end
+
+    def type
+      require(:type)
+    end
+
+    def channel
+      require(:channel)
+    end
+  end
+end

data/lib/logux/add.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Logux
+  class Add
+    attr_reader :client, :version, :password
+
+    def initialize(client: Logux::Client.new,
+                   version: Logux::PROTOCOL_VERSION,
+                   password: Logux.configuration.password)
+      @client = client
+      @version = version
+      @password = password
+    end
+
+    def call(commands)
+      return if commands.empty?
+
+      prepared_data = prepare_data(commands)
+      Logux.logger.debug("Logux add: #{prepared_data}")
+      client.post(prepared_data)
+    end
+
+    private
+
+    def prepare_data(commands)
+      {
+        version: PROTOCOL_VERSION,
+        password: password,
+        commands: commands.map do |command|
+          action = command.first
+          meta = command[1]
+          ['action', action, meta || Meta.new]
+        end
+      }
+    end
+  end
+end

data/lib/logux/auth.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Logux
+  class Auth < Hashie::Mash
+  end
+end

data/lib/logux/base_controller.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Logux
+  class BaseController
+    class << self
+      def verify_authorized!
+        Logux.configuration.verify_authorized = true
+      end
+
+      def unverify_authorized!
+        Logux.configuration.verify_authorized = false
+      end
+    end
+
+    attr_reader :action, :meta
+
+    def initialize(action:, meta: {})
+      @action = action
+      @meta = meta
+    end
+
+    def respond(status, action: @action, meta: @meta, custom_data: nil)
+      Logux::Response.new(status,
+                          action: action,
+                          meta: meta,
+                          custom_data: custom_data)
+    end
+
+    def user_id
+      @user_id ||= meta.user_id
+    end
+
+    def node_id
+      @node_id ||= meta.node_id
+    end
+  end
+end

data/lib/logux/channel_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Logux
+  class ChannelController < BaseController
+    def subscribe
+      Logux.add_batch(initial_data.map { |d| [d, initial_meta] })
+    end
+
+    def initial_data
+      []
+    end
+
+    def initial_meta
+      { clients: [meta.client_id] }
+    end
+
+    def since_time
+      @since_time ||= begin
+        since = action['since'].try(:[], 'time')
+        Time.at(since).to_datetime if since
+      end
+    end
+  end
+end

data/lib/logux/class_finder.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Logux
+  class ClassFinder
+    attr_reader :action, :meta
+
+    def initialize(action:, meta:)
+      @action = action
+      @meta = meta
+    end
+
+    def find_action_class
+      "#{class_namespace}::#{class_name}".constantize
+    rescue NameError
+      message =
+        "Unable to find action #{class_name.camelize}.\n" \
+        "Should be in app/logux/#{class_namespace.downcase}/#{class_path}.rb"
+      raise_error_for_failed_find(message)
+    end
+
+    def find_policy_class
+      "Policies::#{class_namespace}::#{class_name}".constantize
+    rescue NameError
+      message =
+        "Unable to find action policy #{class_name.camelize}.\n" \
+        "Should be in app/logux/#{class_namespace.downcase}/#{class_path}.rb"
+      raise_error_for_failed_find(message)
+    end
+
+    def class_name
+      if subscribe?
+        action.channel_name.camelize
+      else
+        action.type.split('/')[0..-2].map(&:camelize).join('::')
+      end
+    end
+
+    private
+
+    def class_namespace
+      subscribe? ? 'Channels' : 'Actions'
+    end
+
+    def subscribe?
+      action.type == 'logux/subscribe'
+    end
+
+    def action?
+      !subscribe?
+    end
+
+    def class_path
+      "#{class_namespace}::#{class_name}".underscore
+    end
+
+    def raise_error_for_failed_find(message)
+      exception_class = action? ? UnknownActionError : UnknownChannelError
+      raise exception_class.new(message, meta: meta)
+    end
+  end
+end

data/lib/logux/client.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Logux
+  class Client
+    attr_reader :logux_host
+
+    def initialize(logux_host: Logux.configuration.logux_host)
+      @logux_host = logux_host
+    end
+
+    def post(params)
+      client.post(params.to_json,
+                  content_type: :json,
+                  accept: :json)
+    end
+
+    def client
+      @client ||= RestClient::Resource.new(logux_host, verify_ssl: false)
+    end
+  end
+end

data/lib/logux/engine.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Logux
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/logux/error_renderer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Logux
+  class ErrorRenderer
+    attr_reader :exception
+
+    def initialize(exception)
+      @exception = exception
+    end
+
+    def message
+      case exception
+      when Logux::WithMetaError
+        build_message(exception, exception.meta.id)
+      when Logux::UnauthorizedError
+        build_message(exception, exception.message)
+      when StandardError
+        # some runtime error that should be fixed
+        render_stardard_error(exception)
+      end
+    end
+
+    private
+
+    def render_stardard_error(exception)
+      if Logux.configuration.render_backtrace_on_error
+        ['error', exception.message + "\n" + exception.backtrace.join("\n")]
+      else
+        ['error', 'Please look server logs for more information']
+      end
+    end
+
+    def build_message(exception, additional_info)
+      [
+        exception.class.name.demodulize.camelize(:lower).gsub(/Error/, ''),
+        additional_info
+      ]
+    end
+  end
+end

data/lib/logux/meta.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Logux
+  class Meta < Hash
+    def initialize(source_hash = {})
+      merge!(source_hash.stringify_keys)
+
+      self['id'] ||= Logux.generate_action_id
+      self['time'] ||= self['id'].split(' ').first
+    end
+
+    def node_id
+      id.split(' ').second
+    end
+
+    def user_id
+      node_id.split(':').first
+    end
+
+    def client_id
+      node_id.split(':')[0..1].join(':')
+    end
+
+    def logux_order
+      time + ' ' + id.split(' ')[1..-1].join(' ')
+    end
+
+    def time
+      fetch('time')
+    end
+
+    def id
+      fetch('id')
+    end
+  end
+end

data/lib/logux/model.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'model/updater'
+require_relative 'model/proxy'
+require_relative 'model/dsl'
+require_relative 'model/updates_deprecator'
+
+module Logux
+  module Model
+    class InsecureUpdateError < StandardError; end
+
+    def self.included(base)
+      base.extend(DSL)
+
+      base.before_update :touch_logux_order_for_changes,
+                         unless: -> { changes.key?('logux_fields_updated_at') }
+    end
+
+    def logux
+      Proxy.new(self)
+    end
+
+    private
+
+    def touch_logux_order_for_changes
+      attributes = changed.each_with_object({}) do |attr, res|
+        res[attr] = send(attr)
+      end
+
+      updater = Updater.new(model: self, attributes: attributes)
+      self.logux_fields_updated_at = updater.updated_attributes
+
+      ActiveSupport::Notifications.instrument(
+        Logux::Model::UpdatesDeprecator::EVENT,
+        model: self
+      )
+    end
+  end
+end

data/lib/logux/model/dsl.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Logux
+  module Model
+    module DSL
+      def logux_crdt_map_attributes(*attributes)
+        @logux_crdt_mapped_attributes = attributes
+      end
+
+      def logux_crdt_mapped_attributes
+        @logux_crdt_mapped_attributes ||= []
+      end
+    end
+  end
+end

data/lib/logux/model/proxy.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Logux
+  module Model
+    class Proxy
+      def initialize(model)
+        @model = model
+      end
+
+      def update(meta, attributes)
+        updater = Updater.new(
+          model: @model,
+          logux_order: meta.logux_order,
+          attributes: attributes
+        )
+        @model.update_attributes(updater.updated_attributes)
+      end
+
+      def updated_at(field)
+        @model.logux_fields_updated_at[field.to_s]
+      end
+    end
+  end
+end

data/lib/logux/model/updater.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Logux
+  module Model
+    class Updater
+      def initialize(model:, attributes:, logux_order: Logux.generate_action_id)
+        @model = model
+        @logux_order = logux_order
+        @attributes = attributes
+      end
+
+      def updated_attributes
+        newer_updates.merge(logux_fields_updated_at: fields_updated_at)
+      end
+
+      private
+
+      def fields_updated_at
+        @fields_updated_at ||=
+          newer_updates.slice(*tracked_fields)
+                       .keys
+                       .reduce(@model.logux_fields_updated_at) do |acc, attr|
+                         acc.merge(attr => @logux_order)
+                       end
+      end
+
+      def newer_updates
+        @newer_updates ||= @attributes.reject do |attr, _|
+          field_updated_at = @model.logux.updated_at(attr)
+          field_updated_at && field_updated_at > @logux_order
+        end
+      end
+
+      def tracked_fields
+        @model.class.logux_crdt_mapped_attributes
+      end
+    end
+  end
+end