logux_rails 0.1.0 → 0.2.0

data/lib/logux.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'configurations'
-require 'rest-client'
-require 'rails/engine'
-require 'active_support'
-require 'action_controller'
-require 'logux/engine'
-require 'nanoid'
-require 'colorize'
-
-module Logux
-  extend ActiveSupport::Autoload
-  include Configurations
-
-  PROTOCOL_VERSION = 1
-
-  class WithMetaError < StandardError
-    attr_reader :meta
-
-    def initialize(msg, meta: nil)
-      @meta = meta
-      super(msg)
-    end
-  end
-
-  UnknownActionError = Class.new(WithMetaError)
-  UnknownChannelError = Class.new(WithMetaError)
-  UnauthorizedError = Class.new(StandardError)
-
-  autoload :Client, 'logux/client'
-  autoload :Meta, 'logux/meta'
-  autoload :Actions, 'logux/actions'
-  autoload :Auth, 'logux/auth'
-  autoload :BaseController, 'logux/base_controller'
-  autoload :ActionController, 'logux/action_controller'
-  autoload :ChannelController, 'logux/channel_controller'
-  autoload :ClassFinder, 'logux/class_finder'
-  autoload :ActionCaller, 'logux/action_caller'
-  autoload :PolicyCaller, 'logux/policy_caller'
-  autoload :Policy, 'logux/policy'
-  autoload :Add, 'logux/add'
-  autoload :Node, 'logux/node'
-  autoload :Response, 'logux/response'
-  autoload :Stream, 'logux/stream'
-  autoload :Process, 'logux/process'
-  autoload :Logger, 'logux/logger'
-  autoload :Version, 'logux/version'
-  autoload :Test, 'logux/test'
-  autoload :ErrorRenderer, 'logux/error_renderer'
-  autoload :Model, 'logux/model'
-
-  configurable :logux_host, :verify_authorized,
-               :password, :logger,
-               :on_error, :auth_rule,
-               :render_backtrace_on_error
-
-  configuration_defaults do |config|
-    config.logux_host = 'localhost:1338'
-    config.verify_authorized = true
-    config.logger = ActiveSupport::Logger.new(STDOUT)
-    if defined?(Rails) && Rails.respond_to?(:logger)
-      config.logger = Rails.logger
-    end
-    config.on_error = proc {}
-    config.auth_rule = proc { false }
-    config.render_backtrace_on_error = true
-  end
-
-  def self.add(action, meta = Meta.new)
-    Logux::Add.new.call([[action, meta]])
-  end
-
-  def self.add_batch(commands)
-    Logux::Add.new.call(commands)
-  end
-
-  def self.undo(meta, reason: nil, data: {})
-    add(
-      data.merge(type: 'logux/undo', id: meta.id, reason: reason),
-      Logux::Meta.new(clients: [meta.client_id])
-    )
-  end
-
-  def self.verify_request_meta_data(meta_params)
-    if Logux.configuration.password.nil?
-      logger.warn(%(Please, add password for logux server:
-                          Logux.configure do |c|
-                            c.password = 'your-password'
-                          end))
-    end
-    auth = Logux.configuration.password == meta_params&.dig(:password)
-    raise Logux::UnauthorizedError, 'Incorrect password' unless auth
-  end
-
-  def self.process_batch(stream:, batch:)
-    Logux::Process::Batch.new(stream: stream, batch: batch).call
-  end
-
-  def self.generate_action_id
-    Logux::Node.instance.generate_action_id
-  end
-
-  def self.logger
-    configuration.logger
-  end
-end

data/lib/logux/action_caller.rb

@@ -1,42 +0,0 @@
-# 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

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

data/lib/logux/add.rb

@@ -1,37 +0,0 @@
-# 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

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

data/lib/logux/base_controller.rb

@@ -1,37 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-# 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

@@ -1,61 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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/error_renderer.rb

@@ -1,40 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-# 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/node.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  class Node
-    include Singleton
-
-    attr_accessor :last_time, :sequence
-    attr_writer :node_id
-
-    def generate_action_id
-      mutex.synchronize do
-        if last_time && now_time <= last_time
-          @sequence += 1
-        else
-          @sequence = 0
-          @last_time = now_time
-        end
-
-        "#{last_time} #{node_id} #{sequence}"
-      end
-    end
-
-    def node_id
-      @node_id ||= "server:#{Nanoid.generate(size: 8)}"
-    end
-
-    private
-
-    def now_time
-      Time.now.to_datetime.strftime('%Q')
-    end
-
-    def mutex
-      @mutex ||= Mutex.new
-    end
-  end
-end