edgycircle_kommando 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e2962518e6deb43c8cd51657f311ebbd96caf84d0e04cfb7505c7c427fddec0b
+  data.tar.gz: 8cdfe6722fb04875ee8fc3e0fd1240d8c6edbae8dbddb992cc3a9fa89c4c6166
+SHA512:
+  metadata.gz: 895e1f7f17a43f5b9ec5d8fe05a71a09d3b024c55c639f4fcd4c0916597502f0ff23caf352f9001c6d3e45b6b959f134fa590576e83a24383dfc2cf53f9f6434
+  data.tar.gz: cdb250ff046a059b5aaf59f7fcc2384ff8174e9fbdde943826d09280403f41f4bbd9f5ec7127158b5dec014f1128dfd01c7e7e93afcd11ef4004bc4e602722f2

data/db/migrations/1.down.sql

@@ -0,0 +1,2 @@
+DROP INDEX index_kommando_scheduled_commands_on_handle_at;
+DROP TABLE kommando_scheduled_commands;

data/db/migrations/1.up.sql

@@ -0,0 +1,12 @@
+CREATE TABLE kommando_scheduled_commands (
+  id uuid NOT NULL,
+  name character varying NOT NULL,
+  parameters json NOT NULL,
+  handle_at timestamp without time zone NOT NULL,
+  failures json[] NOT NULL,
+  wait_for_command_ids uuid[] DEFAULT '{}'::uuid[],
+
+  PRIMARY KEY (id)
+);
+
+CREATE INDEX index_kommando_scheduled_commands_on_handle_at ON kommando_scheduled_commands USING btree (handle_at);

data/lib/kommando.rb

@@ -0,0 +1,12 @@
+require_relative './kommando/command'
+require_relative './kommando/command_result'
+require_relative './kommando/scheduled_command_runner'
+require_relative './kommando/scheduled_command_worker'
+require_relative './kommando/command_plugins/base'
+require_relative './kommando/command_plugins/execute'
+require_relative './kommando/command_plugins/schedule'
+require_relative './kommando/command_plugins/validate'
+require_relative './kommando/command_plugins/auto_schedule'
+
+module Kommando
+end

data/lib/kommando/active_record.rb

@@ -0,0 +1,9 @@
+require_relative '../kommando'
+
+module Kommando
+  class Railtie < Rails::Railtie
+    initializer 'kommando.initialize' do
+      require_relative './scheduled_command_adapters/active_record'
+    end
+  end
+end

data/lib/kommando/command.rb

@@ -0,0 +1,27 @@
+require_relative './command_plugins/base'
+require_relative './command_plugins/execute'
+require_relative './command_plugins/schedule'
+
+module Kommando
+  class Command
+    class MissingDependencyError < StandardError; end
+
+    class MissingParameterError < StandardError; end
+
+    class ReservedParameterError < StandardError; end
+
+    class UnknownCommandError < StandardError; end
+
+    @options = {}
+
+    def self.plugin(plugin, *args)
+      include plugin::InstanceMethods if defined?(plugin::InstanceMethods)
+      extend plugin::ClassMethods if defined?(plugin::ClassMethods)
+      plugin.configure(self, *args)
+    end
+
+    plugin CommandPlugins::Base
+    plugin CommandPlugins::Execute
+    plugin CommandPlugins::Schedule
+  end
+end

data/lib/kommando/command_plugins/auto_schedule.rb

@@ -0,0 +1,15 @@
+module Kommando
+  module CommandPlugins
+    module AutoSchedule
+      def self.configure(command_klass, options)
+        command_klass.options[:default_handle_at] = options.fetch(:handle_at)
+      end
+
+      module ClassMethods
+        def schedule(dependencies, parameters)
+          super(dependencies, { handle_at: options[:default_handle_at].call }.merge(parameters))
+        end
+      end
+    end
+  end
+end

data/lib/kommando/command_plugins/base.rb

@@ -0,0 +1,17 @@
+module Kommando
+  module CommandPlugins
+    module Base
+      def self.configure(command_klass, *args)
+      end
+
+      module ClassMethods
+        attr_reader :options
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@options, options.dup)
+        end
+      end
+    end
+  end
+end

data/lib/kommando/command_plugins/execute.rb

@@ -0,0 +1,79 @@
+require 'securerandom'
+
+module Kommando
+  module CommandPlugins
+    module Execute
+      def self.configure(command_klass, *args)
+      end
+
+      module ClassMethods
+        def execute(dependencies, parameters)
+          context = {
+            dependencies: dependencies,
+            parameters: parameters,
+            instance: new,
+          }
+
+          context = _before_execute(context)
+          return _halt_with_failure(context) if context.key?(:halt)
+
+          context = _execute(context)
+          return _halt_with_failure(context) if context.key?(:halt)
+
+          context = _after_execute(context)
+          return _halt_with_failure(context) if context.key?(:halt)
+
+          _execute_context_to_result(context)
+        end
+
+        def _before_execute(context)
+          unless context[:parameters].key?(:command_id)
+            context[:parameters] = context[:parameters].merge({ command_id: SecureRandom.uuid })
+          end
+
+          context
+        end
+
+        def _execute(context)
+          context.merge(execute_return_value: context[:instance].handle(context[:dependencies], context[:parameters]))
+        rescue StandardError => error
+          context.merge(halt: { error: :unhandled_exception, data: error })
+        end
+
+        def _after_execute(context)
+          case context[:execute_return_value]
+          when CommandResult::Failure
+            context.merge(halt: context[:execute_return_value])
+          else
+            context
+          end
+        end
+
+        def _execute_context_to_result(context)
+          CommandResult.success(_execute_context_to_data({}, context))
+        end
+
+        def _halt_with_failure(context)
+          case context[:halt]
+          when CommandResult::Failure
+            context[:halt]
+          else
+            CommandResult.failure(_execute_context_to_data({}, context).merge({ error: context[:halt][:error], details: context[:halt][:data] }))
+          end
+        end
+
+        def _execute_context_to_data(data, context)
+          data.merge(context.slice(:parameters)).merge(command: name)
+        end
+
+        private
+        def reserved_parameter_keys
+          [:command_id]
+        end
+      end
+
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/kommando/command_plugins/schedule.rb

@@ -0,0 +1,105 @@
+require 'securerandom'
+
+module Kommando
+  module CommandPlugins
+    module Schedule
+      def self.configure(command_klass, *args)
+      end
+
+      module ClassMethods
+        def schedule(dependencies, parameters)
+          unless dependencies.key?(:schedule_adapter)
+            raise Command::MissingDependencyError, 'You need to provide the `:schedule_adapter` dependency'
+          end
+
+          unless parameters.key?(:handle_at)
+            raise Command::MissingParameterError, 'You need to provide the `:handle_at` parameter'
+          end
+
+          context = {
+            parameters: parameters,
+            schedule_adapter: dependencies[:schedule_adapter],
+            handle_at: parameters[:handle_at].getutc,
+          }
+
+          context = _before_schedule(context)
+          return _halt_schedule_with_failure(context) if context.key?(:halt)
+
+          context = _schedule(context)
+          return _halt_schedule_with_failure(context) if context.key?(:halt)
+
+          context = _after_schedule(context)
+          return _halt_schedule_with_failure(context) if context.key?(:halt)
+
+          _schedule_context_to_result(context)
+        end
+
+        def _before_schedule(context)
+          unless context[:parameters].key?(:command_id)
+            context[:parameters] = context[:parameters].merge({ command_id: SecureRandom.uuid })
+          end
+
+          context
+        end
+
+        def _schedule(context)
+          context.merge(schedule_return_value: context[:schedule_adapter].schedule!(name, context[:parameters], context[:handle_at]))
+        end
+
+        def _after_schedule(context)
+          context
+        end
+
+        def _before_execute(context)
+          context[:instance].scheduled_command_results = []
+          super(context)
+        end
+
+        def _after_execute(context)
+          results = context[:instance].scheduled_command_results
+
+          if failed_result = results.find(&:error?)
+            super(context.merge(halt: CommandResult.failure({ command: name, parameters: context[:parameters] }.merge({ error: :scheduling_error, details: failed_result.error }))))
+          else
+            super(context)
+          end
+        end
+
+        def _schedule_context_to_result(context)
+          CommandResult.success(_schedule_context_to_data({}, context))
+        end
+
+        def _execute_context_to_data(data, context)
+          results = context[:instance].scheduled_command_results
+          super(data.merge(scheduled_commands: results.map(&:value)), context)
+        end
+
+        def _schedule_context_to_data(data, context)
+          data.merge(context.slice(:parameters)).merge(command: name)
+        end
+
+        def _halt_schedule_with_failure(context)
+          case context[:halt]
+          when CommandResult::Failure
+            context[:halt]
+          else
+            CommandResult.failure(_schedule_context_to_data({}, context).merge({ error: context[:halt][:error], details: context[:halt][:data] }))
+          end
+        end
+
+        private
+        def reserved_parameter_keys
+          super.concat([:handle_at, :wait_for_command_ids, :command_id]).uniq
+        end
+      end
+
+      module InstanceMethods
+        attr_accessor :scheduled_command_results
+
+        def scheduled(result)
+          @scheduled_command_results.push(result)
+        end
+      end
+    end
+  end
+end

data/lib/kommando/command_plugins/validate.rb

@@ -0,0 +1,52 @@
+module Kommando
+  module CommandPlugins
+    module Validate
+      def self.configure(command_klass, *args)
+      end
+
+      module ClassMethods
+        def _before_execute(context)
+          if const_defined?('Schema')
+            schema_keys = const_get('Schema').schema.key_map.map(&:name).map(&:to_sym)
+
+            if forbidden_key = reserved_parameter_keys.find { |key| schema_keys.include?(key) }
+              raise Command::ReservedParameterError, "The `#{forbidden_key}` parameter is reserved and cannot be used in command schema"
+            end
+
+            reserved_parameters = context[:parameters].slice(*reserved_parameter_keys)
+            validation_result = const_get('Schema').new.call(context[:parameters])
+
+            if validation_result.success?
+              super(context.merge(parameters: validation_result.to_h.merge(reserved_parameters)))
+            else
+              super(context.merge(halt: { error: :schema_error, data: validation_result.errors.to_h }))
+            end
+          else
+            super(context)
+          end
+        end
+
+        def _before_schedule(context)
+          if const_defined?('Schema')
+            schema_keys = const_get('Schema').schema.key_map.map(&:name).map(&:to_sym)
+
+            if forbidden_key = reserved_parameter_keys.find { |key| schema_keys.include?(key) }
+              raise Command::ReservedParameterError, "The `#{forbidden_key}` parameter is reserved and cannot be used in command schema"
+            end
+
+            reserved_parameters = context[:parameters].slice(*reserved_parameter_keys)
+            validation_result = const_get('Schema').new.call(context[:parameters])
+
+            if validation_result.success?
+              super(context.merge(parameters: validation_result.to_h.merge(reserved_parameters)))
+            else
+              super(context.merge(halt: { error: :schema_error, data: validation_result.errors.to_h }))
+            end
+          else
+            super(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kommando/command_result.rb

@@ -0,0 +1,68 @@
+module Kommando
+  class CommandResult
+    class NonExistentError < StandardError; end
+
+    class NonExistentValue < StandardError; end
+
+    def self.success(value)
+      Success.new(value)
+    end
+
+    def self.failure(error)
+      Failure.new(error)
+    end
+
+    class Success
+      attr_reader :value
+
+      def initialize(value)
+        raise ArgumentError, 'missing `:command` key' unless value.key?(:command)
+        raise ArgumentError, 'missing `:parameters` key' unless value.key?(:parameters)
+        @value = value
+      end
+
+      def error
+        raise NonExistentError, 'Success results do not have errors'
+      end
+
+      def success?
+        true
+      end
+
+      def error?
+        false
+      end
+
+      def deconstruct_keys(_)
+        { value: @value[:command] }.merge(@value)
+      end
+    end
+
+    class Failure
+      attr_reader :error
+
+      def initialize(error)
+        raise ArgumentError, 'missing `:error` key' unless error.key?(:error)
+        raise ArgumentError, 'missing `:command` key' unless error.key?(:command)
+        raise ArgumentError, 'missing `:parameters` key' unless error.key?(:parameters)
+        @error = error
+      end
+
+      def value
+        raise NonExistentValue, 'Failure results do not have values'
+      end
+
+      def success?
+        false
+      end
+
+      def error?
+        true
+      end
+
+      def deconstruct_keys(_)
+        { error: error }.merge(@error)
+      end
+    end
+  end
+end

data/lib/kommando/scheduled_command_adapters/active_record.rb

@@ -0,0 +1,52 @@
+require 'active_record'
+
+module Kommando
+  module ScheduledCommandAdapters
+    class ActiveRecord < ::ActiveRecord::Base
+      self.table_name = 'kommando_scheduled_commands'
+
+      def self.schedule!(command, parameters, handle_at)
+        create!({
+          id: parameters.fetch(:command_id),
+          name: command,
+          parameters: parameters,
+          handle_at: handle_at,
+          failures: [],
+          wait_for_command_ids: parameters.fetch(:wait_for_command_ids, []),
+        })
+      end
+
+      def self.fetch!(&block)
+        transaction do
+          record = lock('FOR UPDATE SKIP LOCKED').
+            where('TIMEZONE(\'UTC\', NOW()) >= handle_at').
+            where.not("wait_for_command_ids && (SELECT array_agg(id) FROM #{table_name})").
+            order(handle_at: :asc).
+            limit(1).
+            first
+
+          if record
+            result = block.call(record.name, record.parameters)
+
+            if result.success?
+              record.destroy
+            else
+              record.update!({
+                failures: record.failures.append(result.error),
+                handle_at: (record.handle_at + 5.minutes).getutc,
+              })
+            end
+          end
+        end
+      end
+
+      def parameters
+        @parameters ||= super.deep_symbolize_keys!
+      end
+
+      def failures
+        @failures ||= super.map(&:deep_symbolize_keys!)
+      end
+    end
+  end
+end

data/lib/kommando/scheduled_command_runner.rb

@@ -0,0 +1,25 @@
+module Kommando
+  class ScheduledCommandRunner
+    def initialize(coordinator, adapter, dependencies)
+      @coordinator = coordinator
+      @adapter = adapter
+      @dependencies = dependencies
+    end
+
+    def call
+      fetched_command = false
+
+      @adapter.fetch! do |command_name, parameters|
+        unless self.class.const_defined?(command_name)
+          raise Command::UnknownCommandError, "Unknown command `#{command_name}`"
+        end
+
+        fetched_command = true
+
+        self.class.const_get(command_name).execute(@dependencies, parameters)
+      end
+
+      @coordinator.schedule_next_run(fetched_command ? 0 : 5)
+    end
+  end
+end

data/lib/kommando/scheduled_command_worker.rb

@@ -0,0 +1,23 @@
+module Kommando
+  class ScheduledCommandWorker
+    def initialize(adapter, dependencies, number_of_threads)
+      @adapter = adapter
+      @dependencies = dependencies
+      @number_of_threads = number_of_threads
+    end
+
+    def start
+      @pool = Concurrent::FixedThreadPool.new(@number_of_threads)
+      @number_of_threads.times { schedule_next_run(0) }
+      @pool.wait_for_termination
+    end
+
+    def stop
+      @pool.shutdown
+    end
+
+    def schedule_next_run(delay)
+      Concurrent::ScheduledTask.execute(delay, { executor: @pool }, &ScheduledCommandRunner.new(self, @adapter, @dependencies).method(:call))
+    end
+  end
+end

data/lib/kommando/version.rb

@@ -0,0 +1,3 @@
+module Kommando
+  VERSION = '1.0.2'
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: edgycircle_kommando
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- David Strauß
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 1970-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Command architecture building blocks.
+email:
+- david.strauss@edgycircle.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- db/migrations/1.down.sql
+- db/migrations/1.up.sql
+- lib/kommando.rb
+- lib/kommando/active_record.rb
+- lib/kommando/command.rb
+- lib/kommando/command_plugins/auto_schedule.rb
+- lib/kommando/command_plugins/base.rb
+- lib/kommando/command_plugins/execute.rb
+- lib/kommando/command_plugins/schedule.rb
+- lib/kommando/command_plugins/validate.rb
+- lib/kommando/command_result.rb
+- lib/kommando/scheduled_command_adapters/active_record.rb
+- lib/kommando/scheduled_command_runner.rb
+- lib/kommando/scheduled_command_worker.rb
+- lib/kommando/version.rb
+homepage: https://github.com/edgycircle/kommando
+licenses:
+- Nonstandard
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []