flow_core 0.0.1

data/app/models/flow_core/place.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module FlowCore
+  class Place < FlowCore::ApplicationRecord
+    self.table_name = "flow_core_places"
+
+    FORBIDDEN_ATTRIBUTES = %i[workflow_id created_at updated_at].freeze
+
+    belongs_to :workflow, class_name: "FlowCore::Workflow"
+
+    # NOTE: Place - out -> Transition - in -> Place
+    has_many :input_arcs, -> { where direction: :out },
+             class_name: "FlowCore::Arc", inverse_of: :place, dependent: :delete_all
+    has_many :output_arcs, -> { where direction: :in },
+             class_name: "FlowCore::Arc", inverse_of: :place, dependent: :delete_all
+
+    has_many :output_transitions, through: :output_arcs, class_name: "FlowCore::Transition", source: :transition
+
+    before_destroy :prevent_destroy
+    after_create :reset_workflow_verification
+    after_destroy :reset_workflow_verification
+
+    def output_implicit_or_split?
+      output_arcs.size > 1
+    end
+
+    def input_or_join?
+      input_arcs.size > 1
+    end
+
+    def input_sequence?
+      input_arcs.size == 1
+    end
+
+    def output_sequence?
+      output_arcs.size == 1
+    end
+
+    def start?
+      false
+    end
+
+    def end?
+      false
+    end
+
+    def can_destroy?
+      workflow.instances.empty?
+    end
+
+    private
+
+      def reset_workflow_verification
+        workflow.reset_workflow_verification!
+      end
+
+      def prevent_destroy
+        unless can_destroy?
+          raise FlowCore::ForbiddenOperation, "Found exists instance, destroy transition will lead serious corruption"
+        end
+      end
+  end
+end

data/app/models/flow_core/start_place.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FlowCore
+  class StartPlace < FlowCore::Place
+    validates :type,
+              uniqueness: {
+                scope: :workflow
+              }
+
+    validates :input_arcs,
+              length: { is: 0 }
+
+    def start?
+      true
+    end
+  end
+end

data/app/models/flow_core/task.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module FlowCore
+  class Task < FlowCore::ApplicationRecord
+    self.table_name = "flow_core_tasks"
+
+    belongs_to :workflow, class_name: "FlowCore::Workflow"
+    belongs_to :transition, class_name: "FlowCore::Transition"
+
+    belongs_to :instance, class_name: "FlowCore::Instance"
+    belongs_to :created_by_token, class_name: "FlowCore::Token", optional: true
+
+    belongs_to :executable, polymorphic: true, optional: true
+
+    serialize :payload
+
+    delegate :payload, to: :instance, prefix: :instance, allow_nil: false
+
+    enum stage: {
+      created: 0,
+      enabled: 1,
+      finished: 11,
+      terminated: 12
+    }
+
+    scope :errored, -> { where.not(errored_at: nil) }
+    scope :suspended, -> { where.not(suspended_at: nil) }
+
+    after_initialize do
+      self.payload ||= {}
+    end
+
+    before_validation do
+      self.workflow ||= instance&.workflow
+    end
+
+    validate do
+      next unless executable
+
+      unless executable.is_a? FlowCore::TaskExecutable
+        errors.add :executable, :invalid
+      end
+    end
+
+    def errored?
+      errored_at.present?
+    end
+
+    def suspended?
+      suspended_at.present?
+    end
+
+    def can_enable?
+      return false unless created?
+
+      if input_free_tokens.size == transition.input_arcs.size
+        return true
+      end
+
+      # Note: It's impossible of it create by a token and needs another token (AND join) to enable?
+      same_origin_tasks.enabled.any?
+    end
+
+    def can_finish?
+      return false unless enabled?
+
+      return false if errored? || suspended?
+
+      if executable
+        executable.finished?
+      else
+        true
+      end
+    end
+
+    def can_terminate?
+      created? || enabled?
+    end
+
+    def enable
+      return false unless can_enable?
+
+      transaction do
+        input_free_tokens.each(&:lock!)
+        update! stage: :enabled, enabled_at: Time.zone.now
+
+        transition.on_task_enabled(self)
+      end
+
+      true
+    end
+
+    def finish
+      return false unless can_finish?
+
+      transaction do
+        # terminate other racing tasks
+        instance.tasks.enabled.where(created_by_token: created_by_token).find_each do |task|
+          task.terminate! reason: "Same origin task #{id} finished"
+        end
+
+        input_locked_tokens.each { |token| token.consume! by: self }
+        update! stage: :finished, finished_at: Time.zone.now
+
+        transition.on_task_finished(self)
+      end
+
+      create_output_token!
+
+      true
+    end
+
+    def terminate(reason:)
+      return false unless can_terminate?
+
+      transaction do
+        update! stage: :terminated, terminated_at: Time.zone.now, terminate_reason: reason
+        transition.on_task_terminated(self)
+      end
+
+      true
+    end
+
+    def enable!
+      enable || raise(FlowCore::InvalidTransition, "Can't enable Task##{id}")
+    end
+
+    def finish!
+      finish || raise(FlowCore::InvalidTransition, "Can't finish Task##{id}")
+    end
+
+    def terminate!(reason:)
+      terminate(reason: reason) || raise(FlowCore::InvalidTransition, "Can't terminate Task##{id}")
+    end
+
+    def error!(error)
+      transaction do
+        update! errored_at: Time.zone.now, error_reason: error.message
+        transition.on_task_errored(self, error)
+
+        instance.error!
+      end
+    end
+
+    def rescue!
+      return unless errored?
+
+      transaction do
+        update! errored_at: nil, rescued_at: Time.zone.now
+        transition.on_task_rescued(self)
+
+        instance.rescue!
+      end
+    end
+
+    def suspend!
+      transaction do
+        update! suspended_at: Time.zone.now
+        transition.on_task_suspended(self)
+      end
+    end
+
+    def resume!
+      transaction do
+        update! suspended_at: nil, resumed_at: Time.zone.now
+        transition.on_task_resumed(self)
+      end
+    end
+
+    def create_output_token!
+      return if output_token_created
+
+      transaction do
+        transition.create_tokens_for_output(task: self)
+        update! output_token_created: true
+      end
+    end
+
+    private
+
+      def input_tokens
+        instance.tokens.where(place: transition.input_places)
+      end
+
+      def input_free_tokens
+        input_tokens.free.uniq(&:place_id)
+      end
+
+      def input_locked_tokens
+        input_tokens.locked.uniq(&:place_id)
+      end
+
+      def same_origin_tasks
+        instance.tasks.where(created_by_token: created_by_token)
+      end
+  end
+end

data/app/models/flow_core/token.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module FlowCore
+  class Token < FlowCore::ApplicationRecord
+    self.table_name = "flow_core_tokens"
+
+    belongs_to :workflow, class_name: "FlowCore::Workflow"
+    belongs_to :instance, class_name: "FlowCore::Instance"
+    belongs_to :place, class_name: "FlowCore::Place"
+
+    belongs_to :created_by_task, class_name: "FlowCore::Task", optional: true
+    belongs_to :consumed_by_task, class_name: "FlowCore::Task", optional: true
+
+    enum stage: {
+      free: 0,
+      locked: 1,
+      consumed: 11,
+      terminated: 12
+    }
+
+    after_create :auto_create_task
+    after_create :auto_enable_task
+    after_create :auto_finish_instance, if: ->(token) { token.place.is_a? EndPlace }
+
+    before_validation do
+      self.workflow ||= instance&.workflow
+    end
+
+    def can_lock?
+      free?
+    end
+
+    def can_consume?
+      locked?
+    end
+
+    def can_terminate?
+      free? || locked?
+    end
+
+    def lock
+      return false unless can_lock?
+
+      update! stage: :locked, locked_at: Time.zone.now
+
+      true
+    end
+
+    def consume(by:)
+      return false unless can_consume?
+
+      update! stage: :consumed,
+              consumed_by_task: by,
+              consumed_at: Time.zone.now
+
+      true
+    end
+
+    def terminate
+      return false unless can_terminate?
+
+      update! stage: :terminated,
+              terminated_at: Time.zone.now
+
+      true
+    end
+
+    def lock!
+      lock || raise(FlowCore::InvalidTransition, "Can't lock Task##{id}")
+    end
+
+    def consume!(by:)
+      consume(by: by) || raise(FlowCore::InvalidTransition, "Can't consume Task##{id}")
+    end
+
+    def terminate!
+      terminate || raise(FlowCore::InvalidTransition, "Can't terminate Task##{id}")
+    end
+
+    def create_task!
+      return if task_created
+
+      transaction do
+        place.output_transitions.each do |transition|
+          transition.create_task_if_needed(token: self)
+        end
+        update! task_created: true
+      end
+    end
+
+    private
+
+      def auto_create_task
+        create_task!
+      end
+
+      def auto_enable_task
+        instance.tasks.created.where(transition: place.output_transitions).find_each(&:enable)
+      end
+
+      def auto_finish_instance
+        instance.finish!
+      end
+  end
+end

data/app/models/flow_core/transition.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module FlowCore
+  class Transition < FlowCore::ApplicationRecord
+    self.table_name = "flow_core_transitions"
+
+    FORBIDDEN_ATTRIBUTES = %i[workflow_id created_at updated_at].freeze
+
+    belongs_to :workflow, class_name: "FlowCore::Workflow"
+
+    # NOTE: Place - out -> Transition - in -> Place
+    has_many :input_arcs, -> { where(direction: :in) },
+             class_name: "FlowCore::Arc", inverse_of: :transition, dependent: :delete_all
+    has_many :output_arcs, -> { where(direction: :out) },
+             class_name: "FlowCore::Arc", inverse_of: :transition, dependent: :delete_all
+
+    has_many :input_places, through: :input_arcs, class_name: "FlowCore::Place", source: :place
+
+    has_one :trigger, class_name: "FlowCore::TransitionTrigger", dependent: :delete
+    has_many :callbacks, class_name: "FlowCore::TransitionCallback", dependent: :delete_all
+
+    before_destroy :prevent_destroy
+    after_create :reset_workflow_verification
+    after_destroy :reset_workflow_verification
+
+    def output_and_split?
+      output_arcs.includes(:guards).all? { |arc| arc.guards.empty? }
+    end
+
+    def output_explicit_or_split?
+      output_arcs.includes(:guards).select { |arc| arc.guards.any? } < output_arcs.size
+    end
+
+    def input_and_join?
+      input_arcs.size > 1
+    end
+
+    def input_sequence?
+      input_arcs.size == 1
+    end
+
+    def output_sequence?
+      output_arcs.size == 1
+    end
+
+    def verify(violations:)
+      trigger&.on_verify(self, violations)
+    end
+
+    def create_task_if_needed(token:)
+      instance = token.instance
+      candidate_tasks = instance.tasks.created.where(transition: self)
+
+      # TODO: Is it possible that a input place has more than one free tokens? if YES we should handle it
+      if candidate_tasks.empty?
+        token.instance.tasks.create! transition: self, created_by_token: token
+      end
+    end
+
+    def create_tokens_for_output(task:)
+      instance = task.instance
+      arcs = output_arcs.includes(:place, :guards).to_a
+
+      end_arc = arcs.find { |arc| arc.place.is_a? EndPlace }
+      if end_arc
+        if end_arc.guards.empty? || end_arc.guards.map { |guard| guard.permit? task }.reduce(&:&)
+          instance.tokens.create! created_by_task: task, place: end_arc.place
+          return
+        end
+
+        arcs.delete(end_arc)
+      end
+
+      candidate_arcs = arcs.select do |arc|
+        arc.guards.empty? || arc.guards.map { |guard| guard.permit? task }.reduce(&:&)
+      end
+
+      if candidate_arcs.empty?
+        trigger&.on_error(task, FlowCore::NoNewTokenCreated.new)
+      end
+
+      candidate_arcs.each do |arc|
+        instance.tokens.create! created_by_task: task, place: arc.place
+      end
+    end
+
+    def on_task_created(task)
+      trigger&.on_task_created(task)
+      callbacks.each { |callback| callback.call task }
+    end
+
+    def on_task_enabled(task)
+      trigger&.on_task_enabled(task)
+      callbacks.each { |callback| callback.call task }
+    end
+
+    def on_task_finished(task)
+      trigger&.on_task_finished(task)
+      callbacks.each { |callback| callback.call task }
+    end
+
+    def on_task_terminated(task)
+      trigger&.on_task_terminated(task)
+      callbacks.each { |callback| callback.call task }
+    end
+
+    def on_task_errored(task, error)
+      trigger&.on_task_errored(task, error)
+      callbacks.each { |callback| callback.call task }
+    end
+
+    def on_task_rescued(task)
+      trigger&.on_task_rescued(task)
+      callbacks.each { |callback| callback.call task }
+    end
+
+    def on_task_suspended(task)
+      trigger&.on_task_suspended(task)
+      callbacks.each { |callback| callback.call task }
+    end
+
+    def on_task_resumed(task)
+      trigger&.on_task_resumed(task)
+      callbacks.each { |callback| callback.call task }
+    end
+
+    def can_destroy?
+      workflow.instances.empty?
+    end
+
+    private
+
+      def reset_workflow_verification
+        workflow.reset_workflow_verification!
+      end
+
+      def prevent_destroy
+        unless can_destroy?
+          raise FlowCore::ForbiddenOperation, "Found exists instance, destroy transition will lead serious corruption"
+        end
+      end
+  end
+end