novel 0.0.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22f3d94e1d471b8ba3371efeb003b406b2f578a64c97ceea090eb28ee80fb471
-  data.tar.gz: 633a42944300e52901c756549d9ea9af7abf956b403a1559a4caa18ac3d73ffd
+  metadata.gz: 97805eb829fb3a4e45917b2d5359f76a7db5ef69272e0521367dc8630a5eb9e4
+  data.tar.gz: cf6b3fab6733a9ee31437756a2b87c98aa7faa9cf11889af50d7335e93affa20
 SHA512:
-  metadata.gz: 85c2b4d3446fcc5f6517d229224dfb5c5e83ad14d12df070856bbdd80c0c265ae319d2d810f465dd3f962068af2b929b2e402c1953040e6de27bf6cfa2ce24e7
-  data.tar.gz: bc0a1ff1f5a7c07c1317e4d5c423da2513e7ffc675661732946095c7ec243a1b3fb1a31c90952d2991436db1071d98bf4c77b80a4ce3185e57a70e72677b2cfd
+  metadata.gz: 1bb0e51ec359686a959c1db3975f788ff5b0b6462930d818f525c278a095afde5eb22ab16c599c706c0582931e835e0792c94d336b9ca8caa6c23556b928cadd
+  data.tar.gz: d7bca07c74c67183ebb2aff147adc16945181983053766ae3eb7469c3ea75947cc92a85bd5f4fe0741402a4135ee87ad79b53fc63d35636af56fab7a8e145e6f

data/Gemfile.lock

@@ -1,13 +1,47 @@
 PATH
   remote: .
   specs:
-    novel (0.0.0)
+    novel (0.3.0)
+      dry-monads (~> 1.3)
+      dry-struct (~> 1.0)
+      state_machines (~> 0.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    concurrent-ruby (1.1.8)
+    connection_pool (2.2.3)
     diff-lcs (1.3)
-    rake (10.5.0)
+    dry-configurable (0.12.1)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.5, >= 0.5.0)
+    dry-container (0.7.2)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+    dry-core (0.5.0)
+      concurrent-ruby (~> 1.0)
+    dry-equalizer (0.3.0)
+    dry-inflector (0.2.0)
+    dry-logic (1.2.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.5, >= 0.5)
+    dry-monads (1.3.5)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.4, >= 0.4.4)
+      dry-equalizer
+    dry-struct (1.4.0)
+      dry-core (~> 0.5, >= 0.5)
+      dry-types (~> 1.5)
+      ice_nine (~> 0.11)
+    dry-types (1.5.1)
+      concurrent-ruby (~> 1.0)
+      dry-container (~> 0.3)
+      dry-core (~> 0.5, >= 0.5)
+      dry-inflector (~> 0.1, >= 0.1.2)
+      dry-logic (~> 1.0, >= 1.0.2)
+    ice_nine (0.11.2)
+    rake (13.0.1)
+    redis (4.2.1)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)
@@ -21,15 +55,18 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.0)
+    state_machines (0.5.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler (~> 2.0)
+  connection_pool
   novel!
-  rake (~> 10.0)
+  rake (~> 13.0)
+  redis
   rspec (~> 3.0)
 
 BUNDLED WITH
-   2.0.2
+   2.1.4

data/README.md

@@ -1,13 +1,25 @@
 # Novel
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/novel`. To experiment with that code, run `bin/console` for an interactive prompt.
+PoC library for orchestration saga pattern. This library can provide DSL for building orchestration objects for your sagas.
 
-TODO: Delete this and the text above, and describe your gem
+The main reason why Novel exists is personal motivation to understand SAGA pattern better and make a great tool for orchestration SAGAs in ruby.
+
+Key concepts:
+
+- Immutable objects only;
+- No global state. It means that you need to use IoC or containers by yourself;
+- Context object as a state of SAGA and only one way to get data in each command;
+- Monads as a result value for each step and full saga flow;
+
+Dependencies:
+
+- `dry-monads` as a result values for everything. Also, saga commands works only with result monads;
+- `dry-types` as a DTO builder for context object;
+- `state_machines` gem as a main state machine implementation;
 
 ## Installation
 
 Add this line to your application's Gemfile:
-
 ```ruby
 gem 'novel'
 ```
@@ -22,7 +34,68 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+You can see all examples in https://github.com/davydovanton/novel/tree/master/examples folder.
+
+### Commands
+The main object of SAGA. Each command should follow specific rules:
+
+- One command - one business step/transaction;
+- Result of each object should be a Result monad (success/failure). When the command returns failure monad Novel starts compensation flow.
+- Each command should take only one argument - `context` object. In context object you can get initial params + result of each step (activity and compensation);
+
+### Building SAGA
+For building orchestration you need to use this DSL:
+
+```ruby
+saga = Novel.compose(logger: Logger.new(STDOUT), repository: :memory | custom_repository_object)
+      .build(name: :booking)
+      .register_step(:car,           activity: { command: ReserveCar.new, retry: 3 },          compensation: { command: CancelCar.new, retry: 3 })
+      .register_step(:notify_hotel,  activity: { command: BookHotelProducer.new },             compensation: { command: CancelHotelHandler.new, async: true })
+      .register_step(:handle_hotel,  activity: { command: BookHotelHandler.new, async: true }, compensation: { command: CancelHotelProducer.new })
+      .register_step(:flight,        activity: { command: BookFlight.new },                    compensation: { command: CancelFlight.new })
+      .build
+
+```
+#### Sync steps
+Sync steps allow you to call the next step without waiting. It means that each step will call the next sync step after self-complete. It's similar to regular interactor/DO notation/dry-transaction flow. To make the sync step you don't need anything. Just put command object to `command` option:
+
+```ruby
+# will create tools step with sync activity command and sync compensation command
+.register_step(:tools, activity: { command: BookTools.new },                     compensation: { command: CancelTools.new })
+```
+
+#### Async steps
+Async steps allow you to wait any time between steps. It's really useful when you're waiting for an event from another part of your system. For example, the activity command produces an event, and the next step waiting when the system consumes a specific event from the message broker. For make async step you just need to add `async: true` option to the command:
+
+```ruby
+# will create two steps:
+#   - notify_hotel step with sync activity command and async compensation command 
+#   - handle_hotel step with async activity command and sync compensation command.
+.register_step(:notify_hotel,  activity: { command: BookHotelProducer.new },             compensation: { command: CancelHotelHandler.new, async: true })
+.register_step(:handle_hotel,  activity: { command: BookHotelHandler.new, async: true }, compensation: { command: CancelHotelProducer.new })
+```
+
+When you working with async steps you need to manually call the saga orchestration object every time to continue flow execution. For the next call you need to send `saga id` instead of params:
+
+```ruby
+
+result = saga.call(params) # first orchestration call
+# => Success(Context(id: uuid))
+saga.call(result.value!.id) # second call for saga flow. In this case you need to put saga id form context object to continue execution flow
+```
+
+### Context object
+Context object provides two options:
+1. getting state of saga flow: it means that you can get the current state of saga execution, returned values for each step, and other useful information.
+2. continue working with the same saga flow in a different place (other instance of an application or other part of your system). We can do it because each context object can persist in any DB. Novel allows persisting context in memory or redis.
+
+For more information check the source code of the context object (https://github.com/davydovanton/novel/blob/master/lib/novel/context.rb)
+
+### Adapters
+
+Novel allows you to persist context in any DB that you want. I implemented memory (only for sync steps) and redis (for sync and async steps). 
+
+You can create a custom repository adapter. For this check redis implementation (https://github.com/davydovanton/novel/blob/master/lib/novel/repository_adapters/redis.rb) and redis example (https://github.com/davydovanton/novel/tree/master/examples/redis) from source code.
 
 ## Development
 
@@ -32,7 +105,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/novel. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/davydovanton/novel. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -40,4 +113,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Novel project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/novel/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Novel project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/davydovanton/novel/blob/master/CODE_OF_CONDUCT.md).

data/examples/failure_saga.rb

@@ -0,0 +1,71 @@
+require "novel"
+require 'dry/monads'
+
+class BaseStep
+  include Dry::Monads[:result]
+
+  def call(context)
+    puts "Step #{self.class}, context: #{context.inspect}"
+    puts
+    Success(result: rand(1..100))
+  end
+end
+
+class ReserveCar < BaseStep
+  def call(context)
+    # sleep(rand(10))
+    puts "Step #{self.class}, context: #{context.inspect}"
+    puts
+    Success(result: rand(1..100))
+  end
+end
+
+class BookHotelProducer < BaseStep; end
+class BookHotelHandler < BaseStep; end
+class BookTools < BaseStep; end
+
+class BookFlight < BaseStep
+  def call(context)
+    puts "!!! Step #{self.class} failed"
+    puts
+    Failure(failure_result: rand(1..100))
+  end
+end
+
+class CancelCar < BaseStep
+  def call(context)
+    # sleep(rand(10))
+    puts "Step #{self.class}, context: #{context.inspect}"
+    puts
+    Success(result: rand(1..100))
+  end
+end
+
+class CancelHotelProducer < BaseStep; end
+class CancelHotelHandler < BaseStep; end
+class CancelTools < BaseStep; end
+class CancelFlight < BaseStep; end
+
+saga = Novel.compose(logger: Logger.new(STDOUT), repository: :memory, timeouts: 5) # timeout in seconds
+      .build(name: :booking)
+      .register_step(:car,           activity: { command: ReserveCar.new, retry: 3 },          compensation: { command: CancelCar.new, retry: 3 })
+      .register_step(:notify_hotel,  activity: { command: BookHotelProducer.new },             compensation: { command: CancelHotelHandler.new, async: true })
+      .register_step(:handle_hotel,  activity: { command: BookHotelHandler.new, async: true }, compensation: { command: CancelHotelProducer.new })
+      .register_step(:tools,         activity: { command: BookTools.new },                     compensation: { command: CancelTools.new })
+      .register_step(:flight,        activity: { command: BookFlight.new },                    compensation: { command: CancelFlight.new })
+      .build
+
+success_result = saga.call(params: { a: 1 })
+
+puts '*'*80
+puts "WAITING EVENT"
+puts '*'*80
+
+saga.call(saga_id: success_result.value![:context].id)
+
+puts '*'*80
+puts "WAITING EVENT"
+puts '*'*80
+
+new_result = saga.call(saga_id: success_result.value![:context].id)
+pp new_result.failure

data/examples/redis/redis_success_saga_1.rb

@@ -0,0 +1,4 @@
+require_relative './saga'
+
+result = SAGA.call(params: { a: 1 })
+pp result

data/examples/redis/redis_success_saga_2.rb

@@ -0,0 +1,5 @@
+require_relative './saga'
+
+# TODO: please, use saga id from redis_success_saga_1.rb file for make it works (you can find this value in the context object)
+new_result = SAGA.call(saga_id: '5db85904-b359-44ed-9672-a9cb6015676c')
+pp new_result

data/examples/redis/saga.rb

@@ -0,0 +1,40 @@
+require "novel"
+require 'dry/monads'
+
+require 'redis'
+require 'connection_pool'
+
+class BaseStep
+  include Dry::Monads[:result]
+
+  def call(context)
+    puts "Step #{self.class}, context: #{context.inspect}"
+    puts
+    Success(result: rand(1..100))
+  end
+end
+
+class ReserveCar < BaseStep; end
+class BookHotelProducer < BaseStep; end
+class BookHotelHandler < BaseStep; end
+class BookTools < BaseStep; end
+class BookFlight < BaseStep; end
+
+class CancelCar < BaseStep; end
+class CancelHotelProducer < BaseStep; end
+class CancelHotelHandler < BaseStep; end
+class CancelTools < BaseStep; end
+class CancelFlight < BaseStep; end
+
+redis = ConnectionPool.new { Redis.new }
+redis_adapter = Novel::RepositoryAdapters::Redis.new(connection_pool: redis)
+repository = Novel::SagaRepository.new(adapter: redis_adapter)
+
+SAGA = Novel.compose(logger: Logger.new(STDOUT), repository: repository, timeouts: 5) # timeout in seconds
+      .build(name: :booking)
+      .register_step(:car,           activity: { command: ReserveCar.new, retry: 3 },          compensation: { command: CancelCar.new, retry: 3 })
+      .register_step(:notify_hotel,  activity: { command: BookHotelProducer.new },             compensation: { command: CancelHotelHandler.new, async: true })
+      .register_step(:handle_hotel,  activity: { command: BookHotelHandler.new, async: true }, compensation: { command: CancelHotelProducer.new })
+      .register_step(:tools,         activity: { command: BookTools.new },                     compensation: { command: CancelTools.new })
+      .register_step(:flight,        activity: { command: BookFlight.new },                    compensation: { command: CancelFlight.new })
+      .build

data/examples/success_saga.rb

@@ -0,0 +1,44 @@
+require "novel"
+require 'dry/monads'
+
+class BaseStep
+  include Dry::Monads[:result]
+
+  def call(context)
+    puts "Step #{self.class}, context: #{context.inspect}"
+    puts
+    Success(result: rand(1..100))
+  end
+end
+
+class ReserveCar < BaseStep
+  def call(context)
+    puts "Step #{self.class}, context: #{context.inspect}"
+    puts
+    Success(result: rand(1..100))
+  end
+end
+
+class BookHotelProducer < BaseStep; end
+class BookHotelHandler < BaseStep; end
+class BookTools < BaseStep; end
+class BookFlight < BaseStep; end
+
+class CancelCar < BaseStep; end
+class CancelHotelProducer < BaseStep; end
+class CancelHotelHandler < BaseStep; end
+class CancelTools < BaseStep; end
+class CancelFlight < BaseStep; end
+
+saga = Novel.compose(logger: Logger.new(STDOUT), repository: :memory) # timeout in seconds
+      .build(name: :booking)
+      .register_step(:car,           activity: { command: ReserveCar.new },        compensation: { command: CancelCar.new, retry: 3 })
+      .register_step(:notify_hotel,  activity: { command: BookHotelProducer.new }, compensation: { command: CancelHotelHandler.new })
+      .register_step(:handle_hotel,  activity: { command: BookHotelHandler.new },  compensation: { command: CancelHotelProducer.new })
+      .register_step(:tools,         activity: { command: BookTools.new },         compensation: { command: CancelTools.new })
+      .register_step(:flight,        activity: { command: BookFlight.new },        compensation: { command: CancelFlight.new })
+      .build
+
+result = saga.call(params: { a: 1 })
+
+pp result

data/lib/novel.rb

@@ -1,6 +1,28 @@
-require "novel/version"
+require 'logger'
+require 'dry/monads'
+require 'securerandom'
+
+require 'novel/state_machines/saga_status'
+require 'novel/state_machines/transaction_status'
+
+require 'novel/container'
+require 'novel/workflow_builder'
+require 'novel/workflow'
+require 'novel/executor'
+require 'novel/saga_repository'
+require 'novel/saga'
+require 'novel/base'
+require 'novel/version'
 
 module Novel
   class Error < StandardError; end
-  # Your code goes here...
+  class InvalidRepositoryError < Error; end
+
+  BASE_LOGGER = Logger.new(STDOUT)
+  ONE_MINUTE = 60
+  MEMORY_REPOSITORY = SagaRepository.new(adapter: RepositoryAdapters::Memory.new)
+
+  def self.compose(repository: MEMORY_REPOSITORY, logger: BASE_LOGGER, timeout: ONE_MINUTE, **args)
+    Base.new(repository: repository, logger: logger, timeout: timeout, **args)
+  end
 end

data/lib/novel/base.rb

@@ -0,0 +1,22 @@
+module Novel
+  class Base
+    attr_reader :logger, :repository
+
+    REPOSITORIES = {
+      memory: SagaRepository.new(adapter: RepositoryAdapters::Memory.new)
+    }
+
+
+
+    def initialize(logger:, repository:, timeout:, **args)
+      @logger = logger
+      @repository = repository.is_a?(Symbol) ? REPOSITORIES[repository] : repository
+      raise InvalidRepositoryError.new("Repository '#{repository}' does not exist in Novel. Please, use custom object insted") unless @repository
+      @timeout = timeout
+    end
+
+    def build(name:)
+      WorkflowBuilder.new(name: name, repository: repository)
+    end
+  end
+end

data/lib/novel/container.rb

@@ -0,0 +1,17 @@
+module Novel
+  class Container
+    attr_reader :_container
+
+    def initialize
+      @_container = {}
+    end
+
+    def register(key, object)
+      _container[key.to_s] = object
+    end
+
+    def resolve(key)
+      _container[key.to_s]
+    end
+  end
+end

data/lib/novel/context.rb

@@ -0,0 +1,50 @@
+require 'securerandom'
+require 'dry-struct'
+
+module Novel
+  class Context  < Dry::Struct
+    module Types
+      include Dry.Types()
+
+      Bool = True | False
+    end
+
+    INIT_SAGA_STATUS = 'started'.freeze
+
+    attribute :id, Types::String
+    attribute :params, Types::Hash.default({}, shared: true)
+    attribute :saga_status, Types::String.default(INIT_SAGA_STATUS)
+
+    attribute? :last_competed_step, Types::Symbol
+    attribute :step_results, Types::Hash.default({}, shared: true)
+
+    attribute? :last_competed_compensation_step, Types::Symbol
+    attribute :compensation_step_results, Types::Hash.default({}, shared: true)
+
+    attribute :failed, Types::Bool.default(false)
+
+    def success?
+      !attributes[:failed]
+    end
+
+    def failed?
+      attributes[:failed]
+    end
+
+    def step(step)
+      attributes[:step_results][step]
+    end
+
+    def completed_steps
+      attributes[:step_results].keys
+    end
+
+    def compensation_step(step)
+      attributes[:compensation_step_results][step]
+    end
+
+    def completed_compensation_steps
+      attributes[:compensation_step_results].keys
+    end
+  end
+end

data/lib/novel/executor.rb

@@ -0,0 +1,42 @@
+require 'novel/executor/activity_flow'
+require 'novel/executor/compensation_flow'
+
+module Novel
+  class Executor
+    include Dry::Monads[:result]
+
+    attr_reader :container, :repository, :activity_flow_executor, :compensation_flow_executor
+
+    def initialize(container:, repository:)
+      @container = container
+      @repository = repository
+
+      @activity_flow_executor = Novel::Executor::ActivityFlow.new(container: container, repository: repository)
+      @compensation_flow_executor = Novel::Executor::CompensationFlow.new(container: container, repository: repository)
+    end
+
+    def start_transaction(saga_id, params, first_step)
+      context = repository.find_or_create_context(saga_id, params)
+      state_machine = StateMachines::SagaStatus.build(state: context.saga_status)
+
+      if state_machine.started?
+        state_machine.wait
+        repository.persist_context(context, saga_status: state_machine.state)
+        return Success(status: :waiting, context: context) if first_step[:async]
+      end
+
+      Success(status: :pending, context: [context, state_machine])
+    end
+
+    def call_activity_flow(context, state_machine, steps)
+      activity_flow_executor.call(context, state_machine, steps)
+    end
+
+    def call_compensation_flow(context, state_machine, steps)
+      compensation_flow_executor.call(context, state_machine, steps)
+    end
+
+    def finish_transaction(context, state_machine)
+    end
+  end
+end

data/lib/novel/executor/activity_flow.rb

@@ -0,0 +1,69 @@
+module Novel
+  class Executor
+    class ActivityFlow
+      include Dry::Monads[:result]
+
+      attr_reader :container, :repository
+
+      def initialize(container:, repository:)
+        @container = container
+        @repository = repository
+      end
+
+      def call(context, state_machine, steps)
+        steps.each_with_index do |step, index|
+          result = execut_step(context, state_machine, step, steps[index + 1])
+
+          return result if result.failure? || result.value![:status] == :waiting
+
+          context = result.value![:context]
+          result
+        end
+
+        Success(status: :finished, context: context)
+      end
+
+    private
+
+      def execut_step(context, state_machine, step, next_step)
+        result = container.resolve("#{step[:name]}.activity").call(context)
+
+        if result.failure?
+          state_machine.ruin
+
+          new_context = repository.persist_context(
+            context,
+            failed: true,
+            saga_status: state_machine.state,
+            last_competed_compensation_step: step[:name],
+            compensation_step_results: context.to_h[:compensation_step_results].merge(step[:name] => result.failure)
+          )
+
+          return Failure(result: result, context: new_context)
+        end
+
+        status = transaction_status(next_step, state_machine)
+
+        Success(
+          status: status,
+          context: repository.persist_context(
+            context,
+            saga_status: state_machine.state,
+            last_competed_step: step[:name],
+            step_results: context.to_h[:step_results].merge(step[:name] => result.value!)
+          )
+        )
+      end
+
+      def transaction_status(next_step, state_machine)
+        if next_step&.fetch(:async) 
+          state_machine.wait
+
+          :waiting
+        else
+          :processing
+        end
+      end
+    end
+  end
+end

data/lib/novel/executor/compensation_flow.rb

@@ -0,0 +1,56 @@
+module Novel
+  class Executor
+    class CompensationFlow
+      include Dry::Monads[:result]
+
+      attr_reader :container, :repository
+
+      def initialize(container:, repository:)
+        @container = container
+        @repository = repository
+      end
+
+      def call(context, state_machine, steps)
+        steps.each_with_index.map do |step, index|
+          result = execut_step(context, state_machine, step, steps[index + 1])
+          context = result.value![:context]
+
+          if result.value![:status] == :waiting
+            return result
+          else
+            result
+          end
+        end
+      end
+
+    private
+
+      def execut_step(context, state_machine, step, next_step)
+        result = container.resolve("#{step[:name]}.compensation").call(context)
+        status = transaction_status(next_step, state_machine)
+
+        Success(
+          status: status,
+          result: result,
+          context: repository.persist_context(
+            context,
+            failed: true,
+            saga_status: state_machine.state,
+            last_competed_compensation_step: step[:name],
+            compensation_step_results: context.to_h[:compensation_step_results].merge(step[:name] => result.value!)
+          )
+        )
+      end
+
+      def transaction_status(next_step, state_machine)
+        if next_step&.fetch(:async) 
+          state_machine.wait
+
+          :waiting
+        else
+          :processing
+        end
+      end
+    end
+  end
+end

data/lib/novel/repository_adapters/memory.rb

@@ -0,0 +1,18 @@
+module Novel
+  module RepositoryAdapters
+    class Memory
+      def initialize
+        @store = {}
+      end
+
+      def find_context(saga_id)
+        @store[saga_id]
+      end
+
+      def persist_context(saga_id, context)
+        @store[saga_id] = context
+        context
+      end
+    end
+  end
+end

data/lib/novel/repository_adapters/redis.rb

@@ -0,0 +1,21 @@
+module Novel
+  module RepositoryAdapters
+    class Redis
+      attr_reader :connection_pool
+
+      def initialize(connection_pool:)
+        @connection_pool = connection_pool
+      end
+
+      def find_context(saga_id)
+        result = connection_pool.with { |r| r.get("novel.sagas.#{saga_id}") }
+        result ? Marshal.load(result) : nil
+      end
+
+      def persist_context(saga_id, context)
+        connection_pool.with { |r| r.set("novel.sagas.#{saga_id}", Marshal.dump(context)) }
+        context
+      end
+    end
+  end
+end

data/lib/novel/saga.rb

@@ -0,0 +1,49 @@
+require "novel/context"
+
+module Novel
+  class Saga
+    include Dry::Monads[:result]
+
+    attr_reader :workflow, :executor
+
+    def initialize(name:, workflow:, executor:)
+      @name = name
+
+      @workflow = workflow
+      @executor = executor
+    end
+
+    def call(params: {}, saga_id: SecureRandom.uuid)
+      start_result = executor.start_transaction(saga_id, params, workflow.activity_steps.first)
+      return start_result if start_result.value![:status] == :waiting
+
+      context, saga_state = start_result.value![:context]
+
+      if context.success?
+        activity_flow_result = executor.call_activity_flow(context, saga_state, workflow.activity_steps_from(context.last_competed_step))
+
+        activity_flow_result.or do |error_result|
+          compensation_result = sync_compensation_result_for(error_result[:context], saga_state, error_result)
+
+          Failure(status: :saga_failed, compensation_result: compensation_result, context: compensation_result.value![:context])
+        end
+      else
+        compensation_steps = workflow.compensation_steps_from(context.last_competed_compensation_step)
+        compensation_result = executor.call_compensation_flow(context, saga_state, compensation_steps)
+
+        Failure(status: :saga_failed, compensation_result: compensation_result, context: compensation_result.last.value![:context])
+      end
+    end
+
+  private
+
+    def sync_compensation_result_for(context, saga_state, error_result)
+      if workflow.next_compensation_step(context.last_competed_compensation_step)[:async]
+        # TODO: saga_state.wait
+        Success(error_result: error_result, context: context)
+      else
+        executor.call_compensation_flow(context, saga_state, workflow.compensation_steps_from(context.last_competed_compensation_step))
+      end
+    end
+  end
+end

data/lib/novel/saga_repository.rb

@@ -0,0 +1,22 @@
+require 'novel/repository_adapters/memory'
+require 'novel/repository_adapters/redis'
+
+module Novel
+  class SagaRepository
+    attr_reader :adapter
+
+    def initialize(adapter: RepositoryAdapters::Memory.new)
+      @adapter = adapter
+    end
+
+    def find_or_create_context(saga_id, params)
+      adapter.find_context(saga_id) || adapter.persist_context(saga_id, Context.new(id: saga_id, params: params))
+    end
+
+    def persist_context(context, **params)
+      new_context = Context.new({ **context.to_h, **params })
+      adapter.persist_context(context.id, new_context)
+      new_context
+    end
+  end
+end

data/lib/novel/state_machines/saga_status.rb

@@ -0,0 +1,34 @@
+require 'state_machines'
+
+module Novel
+  class StateMachines
+    class SagaStatus
+      state_machine initial: :started do
+        event :wait do
+          transition [:started, :processing] => :waiting
+          transition processing_compensation: :waiting_compensation
+        end
+
+        event :process do
+          transition [:started, :waiting] => :processing
+          transition waiting_compensation: :processing_compensation
+        end
+
+        # CONTEXT: "fail" reserved for private api of state machine
+        event :ruin do
+          transition processing: :processing_compensation
+        end
+
+        event :complete do
+          transition [:processing_compensation, :processing] => :completed
+        end
+      end
+
+      def self.build(state: nil)
+        sm = self.new
+        sm.state = state.to_s if state
+        sm
+      end
+    end
+  end
+end

data/lib/novel/state_machines/transaction_status.rb

@@ -0,0 +1,22 @@
+require 'state_machines'
+
+module Novel
+  class StateMachines
+    class TransactionStatus
+      state_machine initial: :waiting do
+        event :process do
+          transition blank: :processing
+        end
+
+        event :complete do
+          transition processing: :completed
+        end
+
+        event :wait do
+          transition completed: :waiting
+        end
+
+      end
+    end
+  end
+end

data/lib/novel/version.rb

@@ -1,3 +1,3 @@
 module Novel
-  VERSION = "0.0.0"
+  VERSION = "0.3.0"
 end

data/lib/novel/workflow.rb

@@ -0,0 +1,72 @@
+module Novel
+  class Workflow
+    attr_reader :raw, :activity_flow, :compensation_flow
+
+    FINISH_STEP = :finish
+
+    def initialize(raw:)
+      @raw = raw
+    end
+
+    def activity_steps
+      @activity_steps ||= raw.map { |step| { name: step[:name], async: step[:activity][:async] } }
+    end
+
+    def activity_steps_from(step)
+      if step
+        next_step_index = activity_flow.index(step) + 1
+        remaining_steps = activity_flow[next_step_index..-1]
+        activity_steps.select { |s, _| remaining_steps.include?(s[:name]) }
+      else
+        activity_steps
+      end
+    end
+
+    def compensation_steps
+      @compensation_steps ||= raw.reverse.map { |step| step[:compensation] ? { name: step[:name], async: step[:compensation][:async] } : nil }.compact
+    end
+
+    def compensation_steps_from(step)
+      # TODO: question should I call compensation logic for failed step or should I call next step in the flow?
+
+      first_compensation_step_index = calculate_compensation_index(next_compensation_step(step)[:name])
+      remaining_steps = compensation_flow[first_compensation_step_index..-1]
+      compensation_steps.select { |s, _| remaining_steps.include?(s[:name]) }
+    end
+
+
+    def next_activity_step(step_name)
+      # activity_flow.include?(step_name)
+
+      activity_steps.find { |s| s[:name] == get_next_by_index(activity_flow, activity_flow.index(step_name)) }
+    end
+
+    def next_compensation_step(step_name)
+      # activity_flow.include?(step_name)
+
+      compensation_steps.find { |s| s[:name] == get_next_by_index(compensation_flow, calculate_compensation_index(step_name)) }
+    end
+
+  private
+    def activity_flow
+      @activity_flow ||= raw.map { |step| step[:name] }
+    end
+
+    def compensation_flow
+      @compensation_flow ||= raw.reverse.map { |step| step[:compensation] ? step[:name] : nil }
+    end
+
+    def calculate_compensation_index(step_name)
+      compensation_flow.include?(step_name) ? compensation_flow.index(step_name) : activity_flow.reverse.index(step_name)
+    end
+
+    def get_next_by_index(list, step_index)
+      next_index = step_index + 1
+      if next_index < list.count
+        list[next_index] || get_next_by_index(list, step_index + 1)
+      else
+        FINISH_STEP
+      end
+    end
+  end
+end

data/lib/novel/workflow_builder.rb

@@ -0,0 +1,38 @@
+module Novel
+  class WorkflowBuilder
+    attr_reader :name, :raw_workflow, :repository
+
+    def initialize(name:, repository:, raw_workflow: [])
+      @name = name
+      @raw_workflow = raw_workflow
+      @repository = repository
+    end
+
+    def register_step(name, activity:, compensation: nil)
+      self.class.new(
+        name: name,
+        repository: repository,
+        raw_workflow: raw_workflow + [{ name: name, activity: activity, compensation: compensation }]
+      )
+    end
+
+    def build
+      Saga.new(
+        name: name,
+        workflow: Workflow.new(raw: raw_workflow),
+        executor: Executor.new(container: build_container, repository: repository)
+      )
+    end
+
+  private
+
+    def build_container
+      container = Container.new
+      raw_workflow.each do |step|
+        container.register("#{step[:name]}.activity", step[:activity][:command])
+        container.register("#{step[:name]}.compensation", step[:compensation][:command])
+      end
+      container
+    end
+  end
+end

data/novel.gemspec

@@ -27,6 +27,14 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_development_dependency "connection_pool"
+  spec.add_development_dependency "redis"
+
+  spec.add_dependency "dry-monads", "~> 1.3"
+  spec.add_dependency "dry-struct", "~> 1.0"
+
+  spec.add_dependency "state_machines", "~> 0.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: novel
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Anton Davydov
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-12-07 00:00:00.000000000 Z
+date: 2021-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,76 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-monads
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: state_machines
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 description: SAGA pattern PoC
 email:
 - antondavydov.o@gmail.com
@@ -70,8 +140,27 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/failure_saga.rb
+- examples/redis/redis_success_saga_1.rb
+- examples/redis/redis_success_saga_2.rb
+- examples/redis/saga.rb
+- examples/success_saga.rb
 - lib/novel.rb
+- lib/novel/base.rb
+- lib/novel/container.rb
+- lib/novel/context.rb
+- lib/novel/executor.rb
+- lib/novel/executor/activity_flow.rb
+- lib/novel/executor/compensation_flow.rb
+- lib/novel/repository_adapters/memory.rb
+- lib/novel/repository_adapters/redis.rb
+- lib/novel/saga.rb
+- lib/novel/saga_repository.rb
+- lib/novel/state_machines/saga_status.rb
+- lib/novel/state_machines/transaction_status.rb
 - lib/novel/version.rb
+- lib/novel/workflow.rb
+- lib/novel/workflow_builder.rb
 - novel.gemspec
 homepage: https://github.com/davydovanton/novel
 licenses:
@@ -79,7 +168,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/davydovanton/novel
   source_code_uri: https://github.com/davydovanton/novel
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -94,8 +183,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: SAGA pattern PoC
 test_files: []