logux-rack 0.1.0

data/lib/logux/process/batch.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Logux
+  module Process
+    class Batch
+      attr_reader :stream, :batch
+
+      def initialize(stream:, batch:)
+        @stream = stream
+        @batch = batch
+      end
+
+      def call
+        last_chunk = batch.size - 1
+        preprocessed_batch.map.with_index do |chunk, index|
+          case chunk[:type]
+          when :action
+            process_action(chunk: chunk.slice(:action, :meta))
+          when :auth
+            process_auth(chunk: chunk[:auth])
+          end
+          stream.write(',') if index != last_chunk
+        end
+      end
+
+      def process_action(chunk:)
+        Logux::Process::Action.new(stream: stream, chunk: chunk).call
+      end
+
+      def process_auth(chunk:)
+        Logux::Process::Auth.new(stream: stream, chunk: chunk).call
+      end
+
+      def preprocessed_batch
+        @preprocessed_batch ||= batch.map do |chunk|
+          case chunk[0]
+          when 'action'
+            preprocess_action(chunk)
+          when 'auth'
+            preprocess_auth(chunk)
+          end
+        end
+      end
+
+      def preprocess_action(chunk)
+        { type: :action,
+          action: Logux::Action.new(chunk[1]),
+          meta: Logux::Meta.new(chunk[2]) }
+      end
+
+      def preprocess_auth(chunk)
+        { type: :auth,
+          auth: Logux::Auth.new(user_id: chunk[1],
+                                credentials: chunk[2],
+                                auth_id: chunk[3]) }
+      end
+    end
+  end
+end

data/lib/logux/rack.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'configurations'
+require 'forwardable'
+require 'json'
+require 'logger'
+require 'nanoid'
+require 'rest-client'
+require 'sinatra/base'
+require 'singleton'
+
+module Logux
+  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)
+  ParameterMissingError = Class.new(StandardError)
+
+  autoload :Client, 'logux/client'
+  autoload :Meta, 'logux/meta'
+  autoload :Action, 'logux/action'
+  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 :Version, 'logux/version'
+  autoload :Test, 'logux/test'
+  autoload :ErrorRenderer, 'logux/error_renderer'
+  autoload :Utils, 'logux/utils'
+  autoload :ActionWatcher, 'logux/action_watcher'
+
+  configurable %i[
+    action_watcher
+    action_watcher_options
+    auth_rule
+    logger
+    logux_host
+    on_error
+    password
+    render_backtrace_on_error
+    verify_authorized
+  ]
+
+  configuration_defaults do |config|
+    config.logux_host = 'localhost:1338'
+    config.verify_authorized = true
+    config.logger = ::Logger.new(STDOUT)
+    config.on_error = proc {}
+    config.auth_rule = proc { false }
+    config.render_backtrace_on_error = true
+    config.action_watcher = Logux::ActionWatcher
+    config.action_watcher_options = {}
+  end
+
+  module Rack
+    autoload :App, 'logux/rack/app'
+  end
+
+  class << self
+    def add(action, meta = Meta.new)
+      Logux::Add.new.call([[action, meta]])
+    end
+
+    def add_batch(commands)
+      Logux::Add.new.call(commands)
+    end
+
+    def 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 verify_request_meta_data(meta_params)
+      if configuration.password.nil?
+        logger.warn(%(Please, add password for logux server:
+                            Logux.configure do |c|
+                              c.password = 'your-password'
+                            end))
+      end
+      auth = configuration.password == meta_params&.dig('password')
+      raise UnauthorizedError, 'Incorrect password' unless auth
+    end
+
+    def process_batch(stream:, batch:)
+      Logux::Process::Batch.new(stream: stream, batch: batch).call
+    end
+
+    def generate_action_id
+      Logux::Node.instance.generate_action_id
+    end
+
+    def logger
+      configuration.logger
+    end
+
+    def action_watcher
+      configuration.action_watcher.new(configuration.action_watcher_options)
+    end
+
+    def watch_action
+      action_watcher.call { yield }
+    end
+
+    def application
+      Logux::Rack::App
+    end
+  end
+end

data/lib/logux/rack/app.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Logux
+  module Rack
+    LOGUX_ROOT_PATH = '/logux'
+
+    class App < Sinatra::Base
+      before do
+        request.body.rewind
+        content_type 'application/json'
+      end
+
+      post LOGUX_ROOT_PATH do
+        stream do |out|
+          begin
+            logux_stream = Logux::Stream.new(out)
+            logux_stream.write('[')
+            Logux.verify_request_meta_data(meta_params)
+            Logux.process_batch(stream: logux_stream, batch: command_params)
+          rescue => e
+            handle_processing_errors(logux_stream, e)
+          ensure
+            logux_stream.write(']')
+            logux_stream.close
+          end
+        end
+      end
+
+      private
+
+      def logux_params
+        @logux_params ||= JSON.parse(request.body.read)
+      end
+
+      def command_params
+        logux_params.dig('commands') || []
+      end
+
+      def meta_params
+        logux_params&.slice('version', 'password')
+      end
+
+      def handle_processing_errors(logux_stream, exception)
+        Logux.configuration.on_error&.call(exception)
+        Logux.logger.error("#{exception}\n#{exception.backtrace.join("\n")}")
+      ensure
+        logux_stream.write(Logux::ErrorRenderer.new(exception).message)
+      end
+    end
+  end
+
+  def self.application
+    Logux::Rack::App
+  end
+end

data/lib/logux/rack/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Logux
+  module Rack
+    VERSION = '0.1.0'
+  end
+end

data/lib/logux/rake_tasks.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'rake/tasklib'
+require_relative 'rack'
+
+module Logux
+  class RakeTasks < ::Rake::TaskLib
+    attr_accessor :name
+    attr_accessor :verbose
+    attr_accessor :fail_on_error
+    attr_accessor :patterns
+    attr_accessor :formatters
+    attr_accessor :requires
+    attr_accessor :options
+
+    using Logux::Utils
+
+    ACTIONS_NAMESPACE = 'Actions'
+    CHANNELS_NAMESPACE = 'Channels'
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def initialize(name = :logux)
+      setup(name)
+      namespace(name) do
+        desc 'Lists all Logux action types'
+        task(:actions, [:actions_path]) do |_, task_args|
+          task_args.with_defaults(actions_path: default_actions_path)
+          require_all(task_args.actions_path)
+          report(ACTIONS_HEAD, action_types)
+        end
+
+        desc 'Lists all Logux channel'
+        task(:channels, [:channels_path]) do |_, task_args|
+          task_args.with_defaults(channels_path: default_channels_path)
+          require_all(task_args.channels_path)
+          report(CHANNELS_HEAD, channels)
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    protected
+
+    def default_actions_path
+      File.join(Dir.pwd, '**', 'actions')
+    end
+
+    def default_channels_path
+      File.join(Dir.pwd, '**', 'channels')
+    end
+
+    private
+
+    def setup(name)
+      @name = name
+      @verbose = true
+      @fail_on_error = true
+      @patterns = []
+      @requires = []
+      @options = []
+      @formatters = []
+    end
+
+    ACTIONS_HEAD = [%w[action.type Class#method]].freeze
+    CHANNELS_HEAD = [%w[channel Class]].freeze
+    private_constant :ACTIONS_HEAD, :CHANNELS_HEAD
+
+    def require_all(path)
+      Dir[File.join(path, '**', '*.rb')].each do |file|
+        require file
+      end
+    end
+
+    def action_types
+      classes = descendants_of(::Logux::ActionController).sort_by(&:name)
+      classes.flat_map { |klass| action_methods(klass) }
+    end
+
+    def action_methods(klass)
+      prefix = action_type(klass)
+      klass.instance_methods(false).sort.map do |action|
+        [[prefix, action].join('/'), [klass.name, action].join('#')]
+      end
+    end
+
+    def action_type(klass)
+      strip_namespace(klass, ACTIONS_NAMESPACE)
+    end
+
+    def channels
+      classes = descendants_of(::Logux::ChannelController)
+      classes.select(&:name).sort_by(&:name).map do |klass|
+        [channel(klass), klass]
+      end
+    end
+
+    def channel(klass)
+      strip_namespace(klass, CHANNELS_NAMESPACE)
+    end
+
+    def strip_namespace(klass, namespace)
+      klass.name.gsub(/^#{namespace}::/, '').underscore
+    end
+
+    def descendants_of(parent)
+      ObjectSpace.each_object(Class).select { |klass| klass < parent }
+    end
+
+    def report(header, items)
+      output = header + items
+      first_column_length = output.map(&:first).max_by(&:length).length
+      output.each do |entity, klass_name|
+        puts "#{entity.rjust(first_column_length, ' ')} #{klass_name}"
+      end
+    end
+  end
+end

data/lib/logux/response.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Logux
+  class Response
+    attr_reader :status, :action, :meta, :custom_data
+
+    def initialize(status, action:, meta:, custom_data: nil)
+      @status = status
+      @action = action
+      @meta = meta
+      @custom_data = custom_data
+    end
+
+    def format
+      [status, custom_data || meta.id]
+    end
+  end
+end

data/lib/logux/stream.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Logux
+  class Stream
+    extend Forwardable
+
+    attr_reader :stream
+
+    def_delegators :stream, :close
+
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def write(payload)
+      processed_payload = process(payload)
+      Logux.logger.debug("Write to Logux response: #{processed_payload}")
+      stream << processed_payload
+    end
+
+    private
+
+    def process(payload)
+      payload.is_a?(::String) ? payload : payload.to_json
+    end
+  end
+end

data/lib/logux/test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Logux
+  module Test
+    class << self
+      attr_accessor :http_requests_enabled
+
+      def enable_http_requests!
+        raise ArgumentError unless block_given?
+
+        begin
+          self.http_requests_enabled = true
+          yield
+        ensure
+          self.http_requests_enabled = false
+        end
+      end
+    end
+
+    module Client
+      def post(params)
+        if Logux::Test.http_requests_enabled
+          super(params)
+        else
+          Logux::Test::Store.instance.add(params.to_json)
+        end
+      end
+    end
+
+    autoload :Helpers, 'logux/test/helpers'
+    autoload :Store, 'logux/test/store'
+    autoload :Matchers, 'logux/test/matchers'
+  end
+end
+Logux::Client.prepend Logux::Test::Client