logux_rails 0.1.0

data/lib/logux/model/updates_deprecator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Logux
+  module Model
+    class UpdatesDeprecator
+      EVENT = 'logux.insecure_update'
+
+      class << self
+        def watch(args = {}, &block)
+          new(args).watch(&block)
+        end
+      end
+
+      def initialize(level: :warn)
+        @level = level
+      end
+
+      def watch(&block)
+        callback = lambda(&method(:handle_insecure_update))
+        ActiveSupport::Notifications.subscribed(callback, EVENT, &block)
+      end
+
+      private
+
+      # rubocop:disable Naming/UncommunicativeMethodParamName
+      def handle_insecure_update(_, _, _, _, args)
+        model = args[:model]
+
+        attributes = model.changed.map(&:to_sym) - [:logux_fields_updated_at]
+        insecure_attributes =
+          attributes & model.class.logux_crdt_mapped_attributes
+        return if insecure_attributes.empty?
+
+        notify_about_insecure_update(insecure_attributes)
+      end
+      # rubocop:enable Naming/UncommunicativeMethodParamName
+
+      def notify_about_insecure_update(insecure_attributes)
+        pluralized_attributes = 'attribute'.pluralize(insecure_attributes.count)
+
+        message = <<~TEXT
+          Logux tracked #{pluralized_attributes} (#{insecure_attributes.join(', ')}) should be updated using model.logux.update(...)
+        TEXT
+
+        case @level
+        when :warn
+          ActiveSupport::Deprecation.warn(message)
+        when :error
+          raise InsecureUpdateError, message
+        end
+      end
+    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,34 @@
+# frozen_string_literal: true
+
+module Logux
+  class PolicyCaller
+    attr_reader :action, :meta
+
+    delegate :logger, :configuration, to: :Logux
+
+    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,27 @@
+# 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
+        authed = Logux.configuration.auth_rule.call(user_id, chunk.credentials)
+        return stream.write(['authenticated', chunk.auth_id]) if authed
+
+        stream.write(['denied', chunk.auth_id])
+      end
+
+      private
+
+      def user_id
+        chunk.node_id.split(':').first
+      end
+    end
+  end
+end

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::Actions.new(chunk[1]),
+          meta: Logux::Meta.new(chunk[2]) }
+      end
+
+      def preprocess_auth(chunk)
+        { type: :auth,
+          auth: Logux::Auth.new(node_id: chunk[1],
+                                credentials: chunk[2],
+                                auth_id: chunk[3]) }
+      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,25 @@
+# frozen_string_literal: true
+
+module Logux
+  class Stream
+    attr_reader :stream
+
+    delegate :close, to: :stream
+
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def write(payload)
+      processed_payload = process(payload)
+      Logux.logger.debug("Write to Logux response: #{processed_payload}")
+      stream.write(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

data/lib/logux/test/helpers.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Logux
+  module Test
+    module Helpers
+      extend ActiveSupport::Concern
+
+      included do
+        before do
+          Logux::Test::Store.instance.reset!
+        end
+      end
+
+      def logux_store
+        Logux::Test::Store.instance.data
+      end
+
+      def send_to_logux(*commands)
+        Logux::Test::Matchers::SendToLogux.new(*commands)
+      end
+
+      def a_logux_meta_with(attributes = {})
+        RSpec::Matchers::BuiltIn::Include.new(attributes.stringify_keys)
+      end
+      alias a_logux_meta a_logux_meta_with
+
+      def a_logux_action_with(attributes = {})
+        RSpec::Matchers::BuiltIn::Include.new(attributes.stringify_keys)
+      end
+      alias a_logux_action a_logux_action_with
+
+      def logux_approved(meta = nil)
+        Logux::Test::Matchers::ResponseChunks.new(
+          meta: meta, includes: ['approved'], excludes: %w[forbidden error]
+        )
+      end
+
+      def logux_processed(meta = nil)
+        Logux::Test::Matchers::ResponseChunks.new(
+          meta: meta, includes: ['processed'], excludes: %w[forbidden error]
+        )
+      end
+
+      def logux_forbidden(meta = nil)
+        Logux::Test::Matchers::ResponseChunks.new(
+          meta: meta, includes: ['forbidden']
+        )
+      end
+
+      def logux_errored(meta = nil)
+        Logux::Test::Matchers::ResponseChunks.new(
+          meta: meta, includes: ['error']
+        )
+      end
+
+      def logux_authenticated(meta = nil)
+        Logux::Test::Matchers::ResponseChunks.new(
+          meta: meta, includes: ['authenticated']
+        )
+      end
+
+      def logux_unauthorized(meta = nil)
+        Logux::Test::Matchers::ResponseChunks.new(
+          meta: meta, includes: ['unauthorized']
+        )
+      end
+
+      def logux_denied(meta = nil)
+        Logux::Test::Matchers::ResponseChunks.new(
+          meta: meta, includes: ['denied']
+        )
+      end
+    end
+  end
+end