dipa 0.1.0.pre.1 → 0.1.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6403004fa28c6c0ae9f9cc40f9da8f5b812ed5ea4feb94bd00210785dd4bb950
-  data.tar.gz: 5d485e3096f6b835520844bf6564354eb07640159f4fc7579566df78c8c7c999
+  metadata.gz: e27263056de7d6f8727bcd7bfad4f15bbf9e2e07672d07df687845d462032a7e
+  data.tar.gz: 3cc2fe847141a3e40a690ae7afe3769314f390c5eecd6e1f2c4f028eab0149b4
 SHA512:
-  metadata.gz: 4903b379f5772adf30f2791c74e6355a3a753bb8808a3d8bf655790e7d601e925806d110ec3561993979b3f3aee9a19c5fade0a7d2b17afc7d856e3b5709fecf
-  data.tar.gz: 4022abee161ffd77df8a8a11f9712285689287b369d994334c0bc82ca0f6615f087d1f9aeafa184536b09e399a74921e26d15e670274e98ae836d7aff033c1fd
+  metadata.gz: 4a42b7fa9b406bedcfc17135e8c15219c6f7aa928ea1b02309a7bb55579689177d3d83e3951ca0080599522a4d0f6f7cef48a50e330009f216b183c7b49d744d
+  data.tar.gz: decbe534571620493f1133de0430987b421c8302435f69aeb29f5480e74bc3b8f5cd834832c124e4928ff2126321b097b0131d76b32e1d251549996607dc725e

data/README.md

@@ -2,27 +2,21 @@
 
 # Dipa
 
-This gem provides an API for parallel processing like the [parallel
-gem](https://github.com/grosser/parallel) but distributed and scalable over
-different machines. All this with minimum configuration and minimum dependencies
-to specific technologies and using the rails ecosystem.
+This gem provides an API for parallel processing like the [parallel gem](https://github.com/grosser/parallel) but
+distributed and scalable over different machines. All this with minimum configuration and minimum dependencies to
+specific technologies and using the rails ecosystem.
 
-Dipa provides a rails engine which depends on
-[ActiveJob](https://guides.rubyonrails.org/active_job_basics.html) and
+Dipa provides a rails engine which depends on [ActiveJob](https://guides.rubyonrails.org/active_job_basics.html) and
 [ActiveStorage](https://guides.rubyonrails.org/active_storage_overview.html).
-You can use whatever backend you like for any of this components and configure
-them for your specific usecase.
+You can use whatever backend you like for any of this components and configure them for your specific usecase.
 
-The purpose of this gem is to distribute load heavy and long running processing
-of large datasets over multiple processes or machines using
-[ActiveJob](https://guides.rubyonrails.org/active_job_basics.html).
+The purpose of this gem is to distribute load heavy and long running processing of large datasets over multiple
+processes or machines using [ActiveJob](https://guides.rubyonrails.org/active_job_basics.html).
 
 ## Installation
 
-Before you install Dipa make sure
-[ActiveJob](https://guides.rubyonrails.org/active_job_basics.html) and
-[ActiveStorage](https://guides.rubyonrails.org/active_storage_overview.html) are
-installed and configured properly.
+Before you install Dipa make sure [ActiveJob](https://guides.rubyonrails.org/active_job_basics.html) and
+[ActiveStorage](https://guides.rubyonrails.org/active_storage_overview.html) are installed and configured properly.
 
 Add this line to your application's Gemfile:
 
@@ -42,21 +36,28 @@ $ gem install dipa
 
 Install Dipa migrations
 ```bash
-bundle exec rake app:dipa:install:migrations
+bundle exec rake dipa:install:migrations
 bundle exec rake db:migrate
 ```
 
 ## Configuration
 
-Dipa can be configured in the application config.
+Dipa can be configured in the application config. These configuration options set the default for this installation.
 
 ```ruby
 config.dipa.agent_queue = :default_queue_for_dipa_agent_jobs
 config.dipa.coordinator_queue = :default_queue_for_coordinator_queue_jobs
+config.dipa.agent_timeout = 900
+config.dipa.agent_processing_timeout = 600
+config.dipa.coordinator_timeout = 0
+config.dipa.coordinator_processing_timeout = 18000
 ```
-
-If not configured `config.active_job.default_queue_name` or `:default` will be
-used.
+-   `config.dipa.agent_queue` defaults to `config.active_job.default_queue_name`
+-   `config.dipa.coordinator_queue` defaults to `config.active_job.default_queue_name`
+-   `config.dipa.agent_timeout` defaults to 0 (no timeout).
+-   `config.dipa.agent_processing_timeout` defaults to 0 (no timeout).
+-   `config.dipa.coordinator_timeout` defaults to 0 (no timeout).
+-   `config.dipa.coordinator_processing_timeout` defaults to 0 (no timeout).
 
 ## Usage
 
@@ -67,8 +68,8 @@ Dipa.map(1..100).with('Integer', :sqrt)
 
 More realistic examples:
 ```ruby
-Dipa.map(large_dataset, options).with('ProcessorClassName', :processor_class_method)
-Dipa.each(large_dataset, options).with('ProcessorClassName', :processor_class_method)
+Dipa.map(large_dataset, options: options).with('ProcessorClassName', :processor_class_method)
+Dipa.each(large_dataset, options: options).with('ProcessorClassName', :processor_class_method)
 ```
 
 `Dipa.map` returns an `Array` of the processed items. The result is in the same order as the input (`large_dataset`).
@@ -79,22 +80,19 @@ Dipa.each(large_dataset, options).with('ProcessorClassName', :processor_class_me
 
 `options` is a hash. Following keys are allowed:
 
-- `agent_queue:` [Symbol] Defaults to `config.dipa.agent_queue`.
-- `coordinator_queue:` [Symbol] Defaults to `config.dipa.coordinator_queue`.
-- `async:` [true|false] Defaults to `false`. Usually no need to change, but
-  could be useful for `Dipa.each` if you have a alternative way to monitor your
-  jobs.
-- `keep_data:` [true|false] Defaults to `false`. Useful for debugging. After
-  processing all `Dipa::Agent` and `Dipa::Coordinator` records and the
-  associated ActiveStorage data will be removed. If you don't want that to
-  happen, set this to `true`.
+-   `agent_queue:` \[Symbol] Defaults to `config.dipa.agent_queue`.
+-   `coordinator_queue:` \[Symbol] Defaults to `config.dipa.coordinator_queue`.
+-   `agent_timeout:` \[Integer] Defaults to `config.dipa.agent_timeout`.
+-   `agent_processing_timeout:` \[Integer] Defaults to `config.dipa.agent_processing_timeout`.
+-   `coordinator_timeout:` \[Integer] Defaults to `config.dipa.coordinator_timeout`.
+-   `coordinator_processing_timeout:` \[Integer] Defaults to `config.dipa.coordinator_processing_timeout`.
+-   `keep_data:` \[true|false] Defaults to `false`. Useful for debugging. After processing all `Dipa::*` records and the
+    associated ActiveStorage data will be removed. If you don't want that to happen, set this to `true`.
 
-`ProcessorClassName` must be a `Class` or a `String`. Defines the class which
-provides the processor method.
+`ProcessorClassName` must be a `Class` or a `String`. Defines the class which provides the processor method.
 
-`:processor_class_method` must be a `Symbol` or a `String`. Defines the method
-which is used to process each single element of `large_dataset`. MUST be a class
-method. MUST except just one element as argument.
+`:processor_class_method` must be a `Symbol` or a `String`. Defines the method which is used to process each single
+element of `large_dataset`. MUST be a class method. MUST except just one element as argument.
 
 ## TODO
 
@@ -102,25 +100,55 @@ method. MUST except just one element as argument.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run
-`bundle exec rspec` to run the tests. You can also run `bin/console` for an
-interactive prompt that will allow you to experiment.
+### With nix
+
+-   Having nix installed. See [https://nixos.org/download.html]() for detailed instructions for your OS.
+    -   Enable flakes.
+        ```shell
+        mkdir -p ~/.config/nix
+        echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf
+        ```
+    -   **Optional but recommended:** Install direnv-nix as described
+        [here](https://github.com/nix-community/nix-direnv#installation)
+    -   Clone this repository
+    -   `cd` into the repository's directory
+    -   Enter shell:
+        -   Without direnv: Execute `nix develop`. You need to enter and leave the shell explicitly every time.
+        -   With direnv:
+            ```shell
+            echo -e "use flake . --impure" > .envrc
+            direnv allow
+            ```
+        -   Shell will start every time you `cd` into the projects directory and stop as soon as you leave it.
+
+    The shell sets up the environment for working with this repository and installs all required tools for this project.
+
+    Changes in the `flake.nix` fix will trigger a rebuild of your devenv environment as soon as you hit the shell
+    (return key/(re-)enter shell). Specifically, it rebuilds parts that needs rebuild only. You can also enforce a
+    rebuild by executing `direnv reload`.
+
+    Starting the shell the first time might take some minutes.
+
+-   Run `bundle install`.
+-   Start services in another terminal window with `devenv up` (as of 15.08.2023 it's mysql). The first
+    run will also setup the database.
+-   Run `bundle exec rake db:migrate`.
+
+### Without nix
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on Codeberg at
-https://codeberg.org/empunkt/dipa. This project is intended to be a safe,
-welcoming space for collaboration, and contributors are expected to adhere to
-the [code of
-conduct](https://codeberg.org/empunkt/dipa/src/branch/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on Codeberg at [https://codeberg.org/empunkt/dipa](). This project is intended
+to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the
+[code of conduct](https://codeberg.org/empunkt/dipa/src/branch/main/CODE_OF_CONDUCT.md).
 
 ## License
 
-The gem is available as open source under the terms of the
-[MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
 ## Code of Conduct
 
-Everyone interacting in the Dipa project's codebases, issue trackers, chat rooms
-and mailing lists is expected to follow the
-[code of conduct](https://codeberg.org/empunkt/dipa/src/branch/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the Dipa project's codebases, issue trackers, chat rooms and mailing lists is expected to follow
+the [code of conduct](https://codeberg.org/empunkt/dipa/src/branch/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -7,4 +7,54 @@ load 'rails/tasks/engine.rake'
 
 load 'rails/tasks/statistics.rake'
 
+require 'annotate'
+Annotate.set_defaults(
+  'active_admin' => 'false',
+  'additional_file_patterns' => [],
+  'routes' => 'false',
+  'models' => 'true',
+  'position_in_routes' => 'before',
+  'position_in_class' => 'before',
+  'position_in_test' => 'before',
+  'position_in_fixture' => 'before',
+  'position_in_factory' => 'before',
+  'position_in_serializer' => 'before',
+  'show_foreign_keys' => 'true',
+  'show_complete_foreign_keys' => 'false',
+  'show_indexes' => 'true',
+  'simple_indexes' => 'false',
+  'model_dir' => 'app/models',
+  'root_dir' => '',
+  'include_version' => 'false',
+  'require' => '',
+  'exclude_tests' => 'true',
+  'exclude_fixtures' => 'true',
+  'exclude_factories' => 'false',
+  'exclude_serializers' => 'false',
+  'exclude_scaffolds' => 'true',
+  'exclude_controllers' => 'true',
+  'exclude_helpers' => 'true',
+  'exclude_sti_subclasses' => 'false',
+  'ignore_model_sub_dir' => 'false',
+  'ignore_columns' => nil,
+  'ignore_routes' => nil,
+  'ignore_unknown_models' => 'false',
+  'hide_limit_column_types' => 'integer,bigint,boolean',
+  'hide_default_column_types' => 'json,jsonb,hstore',
+  'skip_on_db_migrate' => 'false',
+  'format_bare' => 'true',
+  'format_rdoc' => 'false',
+  'format_yard' => 'false',
+  'format_markdown' => 'false',
+  'sort' => 'true',
+  'force' => 'false',
+  'frozen' => 'false',
+  'classified_sort' => 'true',
+  'trace' => 'false',
+  'wrapper_open' => nil,
+  'wrapper_close' => nil,
+  'with_comment' => 'true'
+)
+Annotate.load_tasks
+
 require 'bundler/gem_tasks'

data/app/models/concerns/dipa/models/agent_state_attributes.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Dipa
+  module Models
+    module AgentStateAttributes
+      extend ActiveSupport::Concern
+
+      include Dipa::Models::SettingConstants
+
+      AGENT_EXTRA_FINISHED_STATES = {
+        processing_failed: 'processing_failed',
+        aborted_through_coordinator: 'aborted_through_coordinator',
+        aborted_through_coordinator_timed_out: 'aborted_through_coordinator_timed_out',
+        aborted_through_coordinator_processing_timed_out: 'aborted_through_coordinator_processing_timed_out'
+      }.freeze
+      AGENT_EXTRA_CONTINUING_STATES = {}.freeze
+
+      included do
+        set_constant(konst: :EXTRA_FINISHED_STATES, value: AGENT_EXTRA_FINISHED_STATES)
+        set_constant(konst: :EXTRA_CONTINUING_STATES, value: AGENT_EXTRA_CONTINUING_STATES)
+      end
+    end
+  end
+end

data/app/models/concerns/dipa/models/coordinator_state_attributes.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Dipa
+  module Models
+    module CoordinatorStateAttributes
+      extend ActiveSupport::Concern
+
+      include Dipa::Models::SettingConstants
+
+      COORDINATOR_EXTRA_FINISHED_STATES = {
+        aborted_through_agent: 'aborted_through_agent',
+        aborted_through_agent_timed_out: 'aborted_through_agent_timed_out',
+        aborted_through_agent_processing_timed_out: 'aborted_through_agent_processing_timed_out',
+        aborted_through_agent_processing_failed: 'aborted_through_agent_processing_failed'
+      }.freeze
+      COORDINATOR_EXTRA_CONTINUING_STATES = {}.freeze
+
+      included do
+        set_constant(konst: :EXTRA_FINISHED_STATES, value: COORDINATOR_EXTRA_FINISHED_STATES)
+        set_constant(konst: :EXTRA_CONTINUING_STATES, value: COORDINATOR_EXTRA_CONTINUING_STATES)
+      end
+    end
+  end
+end

data/app/models/concerns/{models/dipa → dipa/models}/dumpable.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Models
-  module Dipa
+module Dipa
+  module Models
     module Dumpable
       extend ActiveSupport::Concern
 
@@ -9,7 +9,7 @@ module Models
         io = StringIO.new(Marshal.dump(data), 'rb')
         filename = "#{attacher}.dat"
 
-        public_send(attacher).attach(io: io, filename: filename)
+        __send__(attacher).attach(io: io, filename: filename)
       end
     end
   end

data/app/models/concerns/{models/dipa → dipa/models}/loadable.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-module Models
-  module Dipa
+module Dipa
+  module Models
     module Loadable
       extend ActiveSupport::Concern
 
       def load_from_file(attacher:)
-        return unless public_send(attacher).attached?
+        return unless __send__(attacher).attached?
 
         Marshal.load( # rubocop:disable Security/MarshalLoad
-          public_send(attacher).download
+          __send__(attacher).download
         )
       end
     end

data/app/models/concerns/dipa/models/setting_constants.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Dipa
+  module Models
+    module SettingConstants
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def set_constant(konst:, value:)
+          return if const_defined?(konst)
+
+          const_set(konst, value)
+        end
+
+        def set_from_merged_constants(konst:, first_from:, second_from:)
+          merged = const_get(first_from).merge(const_get(second_from))
+
+          set_constant(konst: konst, value: merged)
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/dipa/models/state_attribute_handling.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Dipa
+  module Models
+    module StateAttributeHandling
+      extend ActiveSupport::Concern
+
+      include Dipa::Models::SettingConstants
+
+      SHARED_FINISHED_STATES = {
+        aborted: 'aborted',
+        finished: 'finished',
+        processing_failed: 'processing_failed',
+        processing_timed_out: 'processing_timed_out',
+        timed_out: 'timed_out'
+      }.freeze
+      SHARED_CONTINUING_STATES = {
+        initialized: 'initialized',
+        processing: 'processing'
+      }.freeze
+
+      included do |base|
+        set_constant(konst: :SHARED_FINISHED_STATES, value: SHARED_FINISHED_STATES)
+        set_constant(konst: :SHARED_CONTINUING_STATES, value: SHARED_CONTINUING_STATES)
+
+        set_from_merged_constants(konst: :COMBINED_FINISHED_STATES,
+                                  first_from: :SHARED_FINISHED_STATES, second_from: :EXTRA_FINISHED_STATES)
+        set_from_merged_constants(konst: :COMBINED_CONTINUING_STATES,
+                                  first_from: :SHARED_CONTINUING_STATES, second_from: :EXTRA_CONTINUING_STATES)
+        set_from_merged_constants(konst: :COMBINED_STATES,
+                                  first_from: :COMBINED_FINISHED_STATES, second_from: :COMBINED_CONTINUING_STATES)
+
+        # :nocov: Only one branch can be covered here
+        if Rails.version >= '7'
+          enum :state, base::COMBINED_STATES, default: base::COMBINED_STATES[:initialized]
+          validates :state, comparison: { equal_to: base::COMBINED_STATES[:initialized] }, on: :create
+        else
+          enum state: base::COMBINED_STATES, _default: base::COMBINED_STATES[:initialized]
+          validates :state, inclusion: { in: [base::COMBINED_STATES[:initialized]] }, on: :create
+        end
+        # :nocov:
+
+        validates :state, presence: true, inclusion: { in: base::COMBINED_STATES.values }
+
+        before_validation :_set_started_at, if: :_processing_started?
+        before_validation :_set_finished_at, if: :_processing_finished?
+      end
+
+      def finished_state?
+        self.class::COMBINED_FINISHED_STATES.value?(state)
+      end
+
+      def failed_state?
+        self.class::COMBINED_FINISHED_STATES.except(:finished).value?(state)
+      end
+
+      private
+
+      def _set_started_at
+        self.started_at = Time.current
+      end
+
+      def _set_finished_at
+        self.finished_at = Time.current
+      end
+
+      def _processing_started?
+        state_changed?(from: self.class::COMBINED_STATES[:initialized], to: self.class::COMBINED_STATES[:processing])
+      end
+
+      def _processing_finished?
+        state_changed?(from: self.class::COMBINED_STATES[:processing]) &&
+          self.class::COMBINED_FINISHED_STATES.value?(state_change[1])
+      end
+    end
+  end
+end

data/app/models/dipa/agent.rb

@@ -24,12 +24,13 @@
 
 module Dipa
   class Agent < ApplicationRecord
-    include Models::Dipa::Dumpable
-    include Models::Dipa::Loadable
-    include Models::Dipa::StateAttributeHandling
+    include Dipa::Models::Dumpable
+    include Dipa::Models::Loadable
+    include Dipa::Models::AgentStateAttributes
+    include Dipa::Models::StateAttributeHandling
 
     # validation and default for `state` attribute is included by
-    # Models::Dipa::StateAttributeHandling
+    # Dipa::Models::StateAttributeHandling
 
     validates :index, numericality: { only_integer: true }
 
@@ -43,7 +44,7 @@ module Dipa
     has_one_attached :result_dump
 
     def result
-      return unless processed?
+      return unless finished?
 
       load_from_file(attacher: :result_dump)
     end
@@ -52,16 +53,16 @@ module Dipa
       load_from_file(attacher: :source_dump)
     end
 
-    def process!
-      processor_result = coordinator.processor_class_name.constantize
-                                    .public_send(
-                                      coordinator.processor_method_name,
-                                      source
-                                    )
+    def timeout_reached?
+      return false if coordinator.agent_timeout.zero?
 
-      dump_to_file(data: processor_result, attacher: :result_dump)
+      (created_at + coordinator.agent_timeout) < Time.current.floor(Dipa::DATETIME_PRECISION)
+    end
+
+    def processing_timeout_reached?
+      return false if coordinator.agent_processing_timeout.zero?
 
-      finished!
+      (started_at + coordinator.agent_processing_timeout) < Time.current.floor(Dipa::DATETIME_PRECISION)
     end
   end
 end

data/app/models/dipa/coordinator.rb

@@ -8,50 +8,51 @@
 #  agent_queue           :string(255)      not null
 #  coordinator_queue     :string(255)      not null
 #  finished_at           :datetime
-#  keep_data             :boolean          default(FALSE), not null
 #  processor_class_name  :string(255)      not null
 #  processor_method_name :string(255)      not null
 #  size                  :integer          not null
 #  started_at            :datetime
 #  state                 :string(255)      not null
-#  want_result           :boolean          default(TRUE), not null
 #  created_at            :datetime         not null
 #  updated_at            :datetime         not null
 #
 
 module Dipa
   class Coordinator < ApplicationRecord
-    include Models::Dipa::Dumpable
-    include Models::Dipa::Loadable
-    include Models::Dipa::StateAttributeHandling
+    include Dipa::Models::Dumpable
+    include Dipa::Models::Loadable
+    include Dipa::Models::CoordinatorStateAttributes
+    include Dipa::Models::StateAttributeHandling
 
     # validation and default for `state` attribute is included by
-    # Models::Dipa::StateAttributeHandling
-
-    attribute :keep_data, :boolean, default: false
-    attribute :want_result, :boolean, default: true
+    # Dipa::Models::StateAttributeHandling
 
     validates :agent_queue, presence: true
     validates :coordinator_queue, presence: true
 
     validates :size, numericality: { only_integer: true }
-
     validates :started_at, 'dipa/date' => true, allow_nil: true
     validates :finished_at, 'dipa/date' => true, allow_nil: true
-
     validates :processor_class_name, presence: true
     validates :processor_method_name, presence: true
 
-    validates :keep_data, inclusion: [true, false]
-    validates :want_result, inclusion: [true, false]
-
     has_many :agents, dependent: :destroy, inverse_of: :coordinator,
                       foreign_key: :dipa_coordinator_id
 
+    has_one :coordinator_options_record, dependent: :destroy,
+                                         inverse_of: :coordinator,
+                                         foreign_key: :dipa_coordinator_id
+    accepts_nested_attributes_for :coordinator_options_record
+
     has_one_attached :source_dump
 
+    delegate :keep_data?, :want_result?,
+             :agent_timeout, :agent_processing_timeout,
+             :coordinator_timeout, :coordinator_processing_timeout,
+             to: :coordinator_options_record
+
     def result
-      return unless processed?
+      return unless finished?
 
       _result_from_agents
     end
@@ -60,8 +61,20 @@ module Dipa
       load_from_file(attacher: :source_dump)
     end
 
-    def all_agents_created_and_processed?
-      _all_agents_created? && _all_agents_processed?
+    def all_agents_created_and_finished?
+      _all_agents_created? && _all_agents_finished?
+    end
+
+    def timeout_reached?
+      return false if coordinator_timeout.zero?
+
+      (created_at + coordinator_timeout) < Time.current.floor(Dipa::DATETIME_PRECISION)
+    end
+
+    def processing_timeout_reached?
+      return false if coordinator_processing_timeout.zero?
+
+      (started_at + coordinator_processing_timeout) < Time.current.floor(Dipa::DATETIME_PRECISION)
     end
 
     private
@@ -70,8 +83,8 @@ module Dipa
       agents.with_attached_result_dump.order(:index).map(&:result)
     end
 
-    def _all_agents_processed?
-      agents.all?(&:processed?)
+    def _all_agents_finished?
+      agents.all?(&:finished_state?)
     end
 
     def _all_agents_created?

data/app/models/dipa/coordinator_options_record.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: dipa_coordinator_options_records
+#
+#  id                             :bigint           not null, primary key
+#  agent_processing_timeout       :integer          not null
+#  agent_timeout                  :integer          not null
+#  coordinator_processing_timeout :integer          not null
+#  coordinator_timeout            :integer          not null
+#  keep_data                      :boolean          default(FALSE), not null
+#  want_result                    :boolean          default(TRUE), not null
+#  created_at                     :datetime         not null
+#  updated_at                     :datetime         not null
+#  dipa_coordinator_id            :bigint           not null
+#
+# Indexes
+#
+#  index_dipa_coordinator_options_records_on_dipa_coordinator_id  (dipa_coordinator_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (dipa_coordinator_id => dipa_coordinators.id)
+#
+
+module Dipa
+  class CoordinatorOptionsRecord < ApplicationRecord
+    attribute :keep_data, :boolean, default: false
+    attribute :want_result, :boolean, default: true
+
+    attribute :agent_timeout, :integer
+    attribute :agent_processing_timeout, :integer
+    attribute :coordinator_timeout, :integer
+    attribute :coordinator_processing_timeout, :integer
+
+    validates :keep_data, inclusion: [true, false]
+    validates :want_result, inclusion: [true, false]
+
+    validates :agent_timeout,
+              numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :agent_processing_timeout,
+              numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :coordinator_timeout,
+              numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :coordinator_processing_timeout,
+              numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+    belongs_to :coordinator, inverse_of: :coordinator_options_record,
+                             foreign_key: :dipa_coordinator_id
+  end
+end