logux-rack 0.1.0

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,13 @@
+# frozen_string_literal: true
+
+module Logux
+  class Auth
+    attr_reader :user_id, :credentials, :auth_id
+
+    def initialize(user_id:, credentials:, auth_id:)
+      @user_id = user_id
+      @credentials = credentials
+      @auth_id = auth_id
+    end
+  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]&.send(:[], :time)
+        Time.at(since).to_datetime if since
+      end
+    end
+  end
+end

data/lib/logux/class_finder.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Logux
+  class ClassFinder
+    attr_reader :action, :meta
+
+    using Logux::Utils
+
+    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/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 check 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(' ')[0]
+    end
+
+    def node_id
+      id.split(' ')[1]
+    end
+
+    def user_id
+      node_id.split(':')[0]
+    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

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

data/lib/logux/policy.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Logux
+  class Policy
+    class UnauthorizedError < StandardError; end
+
+    attr_reader :action, :meta
+
+    def initialize(action:, meta:)
+      @action = action
+      @meta = meta
+    end
+  end
+end

data/lib/logux/policy_caller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Logux
+  class PolicyCaller
+    extend Forwardable
+
+    attr_reader :action, :meta
+
+    def_delegators :Logux, :logger, :configuration
+
+    def initialize(action:, meta:)
+      @action = action
+      @meta = meta
+    end
+
+    def call!
+      logger.debug('Searching policy for Logux action:' \
+                   " #{action}, meta: #{meta}")
+      policy.public_send("#{action.action_type}?")
+    rescue Logux::UnknownActionError, Logux::UnknownChannelError => e
+      raise e if configuration.verify_authorized
+
+      logger.warn(e)
+    end
+
+    private
+
+    def class_finder
+      @class_finder ||= Logux::ClassFinder.new(action: action, meta: meta)
+    end
+
+    def policy
+      class_finder.find_policy_class.new(action: action, meta: meta)
+    end
+  end
+end

data/lib/logux/process.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Logux
+  module Process
+    autoload :Batch, 'logux/process/batch'
+    autoload :Auth, 'logux/process/auth'
+    autoload :Action, 'logux/process/action'
+  end
+end

data/lib/logux/process/action.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Logux
+  module Process
+    class Action
+      attr_reader :stream, :chunk
+      attr_accessor :stop_process
+
+      def initialize(stream:, chunk:)
+        @stream = stream
+        @chunk = chunk
+      end
+
+      def call
+        process_authorization!
+        process_action!
+      end
+
+      def action_from_chunk
+        @action_from_chunk ||= chunk[:action]
+      end
+
+      def meta_from_chunk
+        @meta_from_chunk ||= chunk[:meta]
+      end
+
+      def stop_process?
+        @stop_process ||= false
+      end
+
+      def stop_process!
+        @stop_process = true
+      end
+
+      private
+
+      def process_action!
+        return if stop_process?
+
+        action_caller = Logux::ActionCaller.new(
+          action: action_from_chunk,
+          meta: meta_from_chunk
+        )
+
+        stream.write(action_caller.call!.format)
+      end
+
+      def process_authorization!
+        policy_caller = Logux::PolicyCaller.new(action: action_from_chunk,
+                                                meta: meta_from_chunk)
+        policy_check = policy_caller.call!
+        status = policy_check ? :approved : :forbidden
+        stream.write([status, meta_from_chunk.id])
+        return stream.write(',') if policy_check
+
+        stop_process!
+      end
+    end
+  end
+end

data/lib/logux/process/auth.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Logux
+  module Process
+    class Auth
+      attr_reader :stream, :chunk
+
+      def initialize(stream:, chunk:)
+        @stream = stream
+        @chunk = chunk
+      end
+
+      def call
+        stream.write([auth_result, chunk.auth_id])
+      end
+
+      AUTHENTICATED = 'authenticated'
+      DENIED = 'denied'
+
+      private
+
+      def auth_result
+        auth_rule(chunk.user_id, chunk.credentials) ? AUTHENTICATED : DENIED
+      end
+
+      def auth_rule(user_id, credentials)
+        Logux.configuration.auth_rule.call(user_id, credentials)
+      end
+    end
+  end
+end