dynflow 1.4.7 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffff17987553c70b701f8f7e8b98f5a159c4d0498ccb45b9d41581204edb1b01
-  data.tar.gz: 1399c875ec759cf98a53925caa822e7e03aa8e1e61d9bd2e1957ab69bb07beb8
+  metadata.gz: 5b33bcad7864102ad9f0f3bb654c7990b3037b7b0620b770d5f34f1495402855
+  data.tar.gz: f4089f0cb793384a764f4aa042268c19d174c989c5d348f63e126eac5fb94716
 SHA512:
-  metadata.gz: 51f14bfdcae3d32aaae92716a48668f119327cb8873130dbff7ce9551b40f64d0283037c5a77c5fdced78b612ed8046a449c44ec55e1377d56d247a0cedf3256
-  data.tar.gz: 54787c9fe54caa7227c4122470e398891e161618f5bb02f49332ea2e5a54190dd263e3d46a12691fe47218a81d026d67417b501e07785d6e9eda0aa89f4dd916
+  metadata.gz: c119f0ce0d3605012206b083b829bc85194d676f762d61a394be6257d376c56388efd72f4a77f78445ece78942c5eb561728031e9a703767113eab7780b9d0e3
+  data.tar.gz: 136dafb81d0766e9c1041a9a52896b4cbe0d300482be729900fd9fe8f83e6095bbc084a6d43d0aa9012b436544690d3c2d774d46f0b9c573775b3707daec3428

data/{test/prepare_travis_env.sh → .github/install_dependencies.sh}

@@ -1,5 +1,7 @@
 #!/usr/bin/env bash
 
+set -x
+
 echo "Setting the environment to use ${DB} database"
 
 BUNDLE_CONFIG=.bundle/config
@@ -12,11 +14,9 @@ EOF
 case $DB in
     mysql)
         sed -i 's/:mysql//'g $BUNDLE_CONFIG
-        mysql -e 'create database travis_ci_test;'
     ;;
     postgresql)
         sed -i 's/:postgresql//'g $BUNDLE_CONFIG
-        psql -c 'create database travis_ci_test;' -U postgres
     ;;
     sqlite3)
         # the tests are by default using sqlite3: do nothing

data/.github/workflows/ruby.yml

@@ -0,0 +1,116 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on: [pull_request]
+
+env:
+  TESTOPTS: --verbose
+
+jobs:
+  rubocop:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.7
+      - name: Setup
+        run: |
+          gem install bundler
+          bundle install --jobs=3 --retry=3
+      - name: Run rubocop
+        run: bundle exec rubocop
+
+  test:
+    runs-on: ubuntu-latest
+    needs: rubocop
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby_version:
+          - 2.5.0
+          - 2.6.0
+          - 2.7.0
+          - 3.0.0
+        concurrent_ruby_ext:
+          - 'true'
+          - 'false'
+        db:
+          - postgresql
+          - mysql
+          - sqlite3
+        include:
+          - db: postgresql
+            conn_string: postgres://postgres@localhost/travis_ci_test
+          - db: mysql
+            conn_string: mysql2://root@127.0.0.1/travis_ci_test
+          - db: sqlite3
+            conn_string: sqlite:/
+        exclude:
+          - db: mysql
+            ruby_version: 2.5.0
+          - db: mysql
+            ruby_version: 2.6.0
+          - db: mysql
+            ruby_version: 3.0.0
+          - db: mysql
+            concurrent_ruby_ext: 'true'
+          - db: sqlite3
+            ruby_version: 2.5.0
+          - db: sqlite3
+            ruby_version: 2.6.0
+          - db: sqlite3
+            ruby_version: 3.0.0
+          - db: sqlite3
+            concurrent_ruby_ext: 'true'
+          - db: postgresql
+            ruby_version: 2.5.0
+            concurrent_ruby_ext: 'true'
+          - db: postgresql
+            ruby_version: 2.6.0
+            concurrent_ruby_ext: 'true'
+          - db: postgresql
+            ruby_version: 3.0.0
+            concurrent_ruby_ext: 'true'
+
+    services:
+      postgres:
+        image: postgres:12.1
+        ports: ['5432:5432']
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+        env:
+          POSTGRES_DB: travis_ci_test
+      mariadb:
+        image: mariadb:10
+        ports: ['3306:3306']
+        env:
+          MYSQL_ALLOW_EMPTY_PASSWORD: 'yes'
+          MYSQL_DATABASE: travis_ci_test
+      redis:
+        image: redis:latest
+        ports: ['6379:6379']
+
+    env:
+      DB: ${{ matrix.db }}
+      DB_CONN_STRING: ${{ matrix.conn_string }}
+      CONCURRENT_RUBY_EXT: "${{ matrix.concurrent_ruby_ext }}"
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby_version }}
+    - name: Install dependencies
+      run: .github/install_dependencies.sh
+    - name: Run tests
+      run: bundle exec rake test

data/lib/dynflow.rb

@@ -76,7 +76,7 @@ module Dynflow
   if defined? ::ActiveJob
     require 'dynflow/active_job/queue_adapter'
 
-    class Railtie < Rails::Railtie
+    class Railtie < ::Rails::Railtie
       config.before_initialize do
         ::ActiveJob::QueueAdapters.send(
           :include,

data/lib/dynflow/action.rb

@@ -93,7 +93,8 @@ module Dynflow
       fields! execution_plan_id: String,
               step_id:           Integer,
               event:             Object,
-              time:              type { variants Time, NilClass }
+              time:              type { variants Time, NilClass },
+              optional:          Algebrick::Types::Boolean
     end
 
     def self.constantize(action_name)
@@ -332,9 +333,9 @@ module Dynflow
 
     # Plan an +event+ to be send to the action defined by +action+, what defaults to be self.
     # if +time+ is not passed, event is sent as soon as possible.
-    def plan_event(event, time = nil, execution_plan_id: self.execution_plan_id, step_id: self.run_step_id)
+    def plan_event(event, time = nil, execution_plan_id: self.execution_plan_id, step_id: self.run_step_id, optional: false)
       time = @world.clock.current_time + time if time.is_a?(Numeric)
-      delayed_events << DelayedEvent[execution_plan_id, step_id, event, time]
+      delayed_events << DelayedEvent[execution_plan_id, step_id, event, time, optional]
     end
 
     def delayed_events

data/lib/dynflow/action/suspended.rb

@@ -9,14 +9,14 @@ module Dynflow
       @step_id           = action.run_step_id
     end
 
-    def plan_event(event, time, sent = Concurrent::Promises.resolvable_future)
-      @world.plan_event(execution_plan_id, step_id, event, time, sent)
+    def plan_event(event, time, sent = Concurrent::Promises.resolvable_future, optional: false)
+      @world.plan_event(execution_plan_id, step_id, event, time, sent, optional: optional)
     end
 
-    def event(event, sent = Concurrent::Promises.resolvable_future)
+    def event(event, sent = Concurrent::Promises.resolvable_future, optional: false)
       # TODO: deprecate 2 levels backtrace (to know it's called from clock or internaly)
       # remove lib/dynflow/clock.rb ClockReference#ping branch condition on removal.
-      plan_event(event, nil, sent)
+      plan_event(event, nil, sent, optional: optional)
     end
 
     def <<(event = nil)

data/lib/dynflow/action/timeouts.rb

@@ -7,8 +7,8 @@ module Dynflow
       fail("Timeout exceeded.")
     end
 
-    def schedule_timeout(seconds)
-      plan_event(Timeout, seconds)
+    def schedule_timeout(seconds, optional: false)
+      plan_event(Timeout, seconds, optional: optional)
     end
  end
 end

data/lib/dynflow/actor.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 module Dynflow
 
+  FULL_BACKTRACE = %w[1 y yes].include?((ENV['DYNFLOW_FULL_BACKTRACE'] || '').downcase)
+  BACKTRACE_LIMIT = begin
+                      limit = ENV['DYNFLOW_BACKTRACE_LIMIT'].to_i
+                      limit.zero? ? nil : limit
+                    end
+
   module MethodicActor
     def on_message(message)
       method, *args = message
@@ -44,7 +50,11 @@ module Dynflow
       include LogWithFullBacktrace
 
       def on_envelope(envelope)
-        Actor::BacktraceCollector.with_backtrace(envelope.origin_backtrace) { super }
+        if FULL_BACKTRACE
+          Actor::BacktraceCollector.with_backtrace(envelope.origin_backtrace) { super }
+        else
+          super
+        end
       end
     end
 
@@ -83,9 +93,15 @@ module Dynflow
 
         # takes an array of backtrace lines and replaces each chunk
         def filter_backtrace(backtrace)
-          backtrace.map { |line| filter_line(line) }
-            .chunk_while { |l1, l2| l1 == l2}
-            .map(&:first)
+          trace = backtrace.map { |line| filter_line(line) }
+                           .chunk_while { |l1, l2| l1 == l2}
+                           .map(&:first)
+          if BACKTRACE_LIMIT
+            count = trace.count
+            trace = trace.take(BACKTRACE_LIMIT)
+            trace << "[ backtrace omitted #{count - BACKTRACE_LIMIT} lines ]" if trace.count < count
+          end
+          trace
         end
       end
     end

data/lib/dynflow/clock.rb

@@ -114,11 +114,11 @@ module Dynflow
       Time.now
     end
 
-    def ping(who, time, with_what = nil, where = :<<)
+    def ping(who, time, with_what = nil, where = :<<, optional: false)
       Type! time, Time, Numeric
       time  = current_time + time if time.is_a? Numeric
       if who.is_a?(Action::Suspended)
-        who.plan_event(with_what, time)
+        who.plan_event(with_what, time, optional: optional)
       else
         timer = Clock::Timer[who, time, with_what.nil? ? Algebrick::Types::None : Some[Object][with_what], where]
         self.tell([:add_timer, timer])

data/lib/dynflow/director.rb

@@ -15,7 +15,8 @@ module Dynflow
               execution_plan_id: String,
               step_id:           Integer,
               event:             Object,
-              result:            Concurrent::Promises::ResolvableFuture
+              result:            Concurrent::Promises::ResolvableFuture,
+              optional:          Algebrick::Types::Boolean
     end
 
     UnprocessableEvent = Class.new(Dynflow::Error)
@@ -163,6 +164,9 @@ module Dynflow
       execution_plan_manager = @execution_plan_managers[event.execution_plan_id]
       if execution_plan_manager
         execution_plan_manager.event(event)
+      elsif event.optional
+        event.result.reject "no manager for #{event.inspect}"
+        []
       else
         raise Dynflow::Error, "no manager for #{event.inspect}"
       end

data/lib/dynflow/director/running_steps_manager.rb

@@ -20,8 +20,8 @@ module Dynflow
       def terminate
         pending_work = @work_items.clear.values.flatten(1)
         pending_work.each do |w|
-          if EventWorkItem === w && w.event.result
-            w.event.result.reject UnprocessableEvent.new("dropping due to termination")
+          finish_event_result(w) do |result|
+            result.reject UnprocessableEvent.new("dropping due to termination")
           end
         end
       end

data/lib/dynflow/dispatcher.rb

@@ -6,7 +6,8 @@ module Dynflow
         fields! execution_plan_id: String,
                 step_id:           Integer,
                 event:             Object,
-                time:              type { variants Time, NilClass }
+                time:              type { variants Time, NilClass },
+                optional:          Algebrick::Types::Boolean
       end
 
       Execution = type do

data/lib/dynflow/dispatcher/client_dispatcher.rb

@@ -132,11 +132,13 @@ module Dynflow
       end
 
       def dispatch_request(request, client_world_id, request_id)
+        ignore_unknown = false
         executor_id = match request,
                             (on ~Execution do |execution|
                                AnyExecutor
                              end),
                             (on ~Event do |event|
+                               ignore_unknown = event.optional
                                find_executor(event.execution_plan_id)
                              end),
                             (on Ping.(~any, ~any) | Status.(~any, ~any) do |receiver_id, _|
@@ -144,7 +146,11 @@ module Dynflow
                              end)
         envelope = Envelope[request_id, client_world_id, executor_id, request]
         if Dispatcher::UnknownWorld === envelope.receiver_id
-          raise Dynflow::Error, "Could not find an executor for #{envelope}"
+          raise Dynflow::Error, "Could not find an executor for #{envelope}" unless ignore_unknown
+
+          message = "Could not find an executor for optional #{envelope}, discarding."
+          log(Logger::DEBUG, message)
+          return respond(envelope, Failed[message])
         end
         connector.send(envelope).value!
       rescue => e

data/lib/dynflow/dispatcher/executor_dispatcher.rb

@@ -52,12 +52,14 @@ module Dynflow
           end
         end
         if event_request.time.nil? || event_request.time < Time.now
-          @world.executor.event(envelope.request_id, event_request.execution_plan_id, event_request.step_id, event_request.event, future)
+          @world.executor.event(envelope.request_id, event_request.execution_plan_id, event_request.step_id, event_request.event, future,
+                                optional: event_request.optional)
         else
           @world.clock.ping(
             @world.executor,
             event_request.time,
-            Director::Event[envelope.request_id, event_request.execution_plan_id, event_request.step_id, event_request.event, Concurrent::Promises.resolvable_future],
+            Director::Event[envelope.request_id, event_request.execution_plan_id, event_request.step_id, event_request.event, Concurrent::Promises.resolvable_future,
+                            event_request.optional],
             :delayed_event
           )
           # resolves the future right away - currently we do not wait for the clock ping

data/lib/dynflow/execution_history.rb

@@ -12,7 +12,7 @@ module Dynflow
 
     module Event
       def inspect
-        "#{Time.at(time).utc}: #{name}".tap { |s| s << " @ #{world_id}" if world_id }
+        ["#{Time.at(time).utc}: #{name}", world_id].compact.join(' @ ')
       end
     end
 

data/lib/dynflow/execution_plan.rb

@@ -418,6 +418,14 @@ module Dynflow
       end
     end
 
+    def self.load_flow(flow_hash)
+      if flow_hash.is_a? Hash
+        Flows::Abstract.from_hash(flow_hash)
+      else
+        Flows::Abstract.decode(flow_hash)
+      end
+    end
+
     def to_hash
       recursive_to_hash id:                id,
                         class:             self.class.to_s,
@@ -425,8 +433,8 @@ module Dynflow
                         state:             state,
                         result:            result,
                         root_plan_step_id: root_plan_step && root_plan_step.id,
-                        run_flow:          run_flow,
-                        finalize_flow:     finalize_flow,
+                        run_flow:          run_flow.encode,
+                        finalize_flow:     finalize_flow.encode,
                         step_ids:          steps.map { |id, _| id },
                         started_at:        time_to_str(started_at),
                         ended_at:          time_to_str(ended_at),
@@ -448,8 +456,8 @@ module Dynflow
                hash[:label],
                hash[:state],
                steps[hash[:root_plan_step_id]],
-               Flows::Abstract.from_hash(hash[:run_flow]),
-               Flows::Abstract.from_hash(hash[:finalize_flow]),
+               load_flow(hash[:run_flow]),
+               load_flow(hash[:finalize_flow]),
                steps,
                string_to_time(hash[:started_at]),
                string_to_time(hash[:ended_at]),

data/lib/dynflow/executors/abstract/core.rb

@@ -37,7 +37,7 @@ module Dynflow
 
         def plan_events(delayed_events)
           delayed_events.each do |event|
-            @world.plan_event(event.execution_plan_id, event.step_id, event.event, event.time)
+            @world.plan_event(event.execution_plan_id, event.step_id, event.event, event.time, optional: event.optional)
           end
         end
 

data/lib/dynflow/executors/parallel.rb

@@ -33,8 +33,8 @@ module Dynflow
         raise e
       end
 
-      def event(request_id, execution_plan_id, step_id, event, future = nil)
-        @core.ask([:handle_event, Director::Event[request_id, execution_plan_id, step_id, event, future]])
+      def event(request_id, execution_plan_id, step_id, event, future = nil, optional: false)
+        @core.ask([:handle_event, Director::Event[request_id, execution_plan_id, step_id, event, future, optional]])
         future
       end
 

data/lib/dynflow/flows.rb

@@ -4,6 +4,7 @@ require 'forwardable'
 module Dynflow
   module Flows
 
+    require 'dynflow/flows/registry'
     require 'dynflow/flows/abstract'
     require 'dynflow/flows/atom'
     require 'dynflow/flows/abstract_composed'

data/lib/dynflow/flows/abstract.rb

@@ -32,6 +32,20 @@ module Dynflow
       def flatten!
         raise NotImplementedError
       end
+
+      def self.new_from_hash(hash)
+        check_class_matching hash
+        new(hash[:flows].map { |flow_hash| from_hash(flow_hash) })
+      end
+
+      def self.decode(data)
+        if data.is_a? Integer
+          Flows::Atom.new(data)
+        else
+          kind, *subflows = data
+          Registry.decode(kind).new(subflows.map { |subflow| self.decode(subflow) })
+        end
+      end
     end
   end
 end

data/lib/dynflow/flows/abstract_composed.rb

@@ -11,8 +11,8 @@ module Dynflow
         @flows = flows
       end
 
-      def to_hash
-        super.merge recursive_to_hash(:flows => flows)
+      def encode
+        [Registry.encode(self)] + flows.map(&:encode)
       end
 
       def <<(v)
@@ -61,11 +61,6 @@ module Dynflow
 
       protected
 
-      def self.new_from_hash(hash)
-        check_class_matching hash
-        new(hash[:flows].map { |flow_hash| from_hash(flow_hash) })
-      end
-
       # adds the +new_flow+ in a way that it's in sequence with
       # the +satisfying_flows+
       def add_to_sequence(satisfying_flows, new_flow)

data/lib/dynflow/flows/atom.rb

@@ -5,8 +5,8 @@ module Dynflow
 
       attr_reader :step_id
 
-      def to_hash
-        super.merge(:step_id => step_id)
+      def encode
+        step_id
       end
 
       def initialize(step_id)

data/lib/dynflow/flows/concurrence.rb

@@ -25,5 +25,7 @@ module Dynflow
         return Concurrence.new(extracted_sub_flows)
       end
     end
+
+    Registry.register!(Concurrence, 'C')
   end
 end

data/lib/dynflow/flows/registry.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Dynflow
+  module Flows
+    class Registry
+      class IdentifierTaken < ArgumentError; end
+      class UnknownIdentifier < ArgumentError; end
+
+      class << self
+        def register!(klass, identifier)
+          if (found = serialization_map[identifier])
+            raise IdentifierTaken, "Error setting up mapping #{identifier} to #{klass}, it already maps to #{found}"
+          else
+            serialization_map.update(identifier => klass)
+          end
+        end
+
+        def encode(klass)
+          klass = klass.class unless klass.is_a?(Class)
+          serialization_map.invert[klass] || raise(UnknownIdentifier, "Could not find mapping for #{klass}")
+        end
+
+        def decode(identifier)
+          serialization_map[identifier] || raise(UnknownIdentifier, "Could not find mapping for #{identifier}")
+        end
+
+        def serialization_map
+          @serialization_map ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/dynflow/flows/sequence.rb

@@ -10,5 +10,7 @@ module Dynflow
         self << dependent_flow
       end
     end
+
+    Registry.register!(Sequence, 'S')
   end
 end

data/lib/dynflow/persistence_adapters/sequel.rb

@@ -394,7 +394,7 @@ module Dynflow
 
       def dump_data(value)
         return if value.nil?
-        MultiJson.dump Type!(value, Hash, Array)
+        MultiJson.dump Type!(value, Hash, Array, Integer)
       end
 
       def paginate(data_set, options)

data/lib/dynflow/testing/in_thread_executor.rb

@@ -34,8 +34,8 @@ module Dynflow
         @director.work_finished(work_item)
       end
 
-      def event(execution_plan_id, step_id, event, future = Concurrent::Promises.resolvable_future)
-        event = (Director::Event[SecureRandom.uuid, execution_plan_id, step_id, event, future])
+      def event(execution_plan_id, step_id, event, future = Concurrent::Promises.resolvable_future, optional: false)
+        event = (Director::Event[SecureRandom.uuid, execution_plan_id, step_id, event, future, optional])
         @director.handle_event(event).each do |work_item|
           @work_items << work_item
         end

data/lib/dynflow/testing/in_thread_world.rb

@@ -58,15 +58,15 @@ module Dynflow
         future.reject e
       end
 
-      def event(execution_plan_id, step_id, event, done = Concurrent::Promises.resolvable_future)
-        @executor.event(execution_plan_id, step_id, event, done)
+      def event(execution_plan_id, step_id, event, done = Concurrent::Promises.resolvable_future, optional: false)
+        @executor.event(execution_plan_id, step_id, event, done, optional: optional)
       end
 
-      def plan_event(execution_plan_id, step_id, event, time, done = Concurrent::Promises.resolvable_future)
+      def plan_event(execution_plan_id, step_id, event, time, done = Concurrent::Promises.resolvable_future, optional: false)
         if time.nil? || time < Time.now
-          event(execution_plan_id, step_id, event, done)
+          event(execution_plan_id, step_id, event, done, optional: optional)
         else
-          clock.ping(executor, time, Director::Event[SecureRandom.uuid, execution_plan_id, step_id, event, done], :delayed_event)
+          clock.ping(executor, time, Director::Event[SecureRandom.uuid, execution_plan_id, step_id, event, done, optional], :delayed_event)
         end
       end
     end

data/lib/dynflow/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Dynflow
-  VERSION = '1.4.7'
+  VERSION = '1.5.0'
 end

data/lib/dynflow/world.rb

@@ -219,12 +219,12 @@ module Dynflow
       publish_request(Dispatcher::Execution[execution_plan_id], done, true)
     end
 
-    def event(execution_plan_id, step_id, event, done = Concurrent::Promises.resolvable_future)
-      publish_request(Dispatcher::Event[execution_plan_id, step_id, event], done, false)
+    def event(execution_plan_id, step_id, event, done = Concurrent::Promises.resolvable_future, optional: false)
+      publish_request(Dispatcher::Event[execution_plan_id, step_id, event, nil, optional], done, false)
     end
 
-    def plan_event(execution_plan_id, step_id, event, time, accepted = Concurrent::Promises.resolvable_future)
-      publish_request(Dispatcher::Event[execution_plan_id, step_id, event, time], accepted, false)
+    def plan_event(execution_plan_id, step_id, event, time, accepted = Concurrent::Promises.resolvable_future, optional: false)
+      publish_request(Dispatcher::Event[execution_plan_id, step_id, event, time, optional], accepted, false)
     end
 
     def ping(world_id, timeout, done = Concurrent::Promises.resolvable_future)

data/test/dispatcher_test.rb

@@ -49,6 +49,12 @@ module Dynflow
               plan = result.finished.value
               assert_equal('finish', plan.actions.first.output[:event])
             end
+
+            it 'does not error on dispatching an optional event' do
+              request = client_world.event('123', 1, nil, optional: true)
+              request.wait(20)
+              assert_match /Could not find an executor for optional .*, discarding/, request.reason.message
+            end
           end
         end
       end

data/test/flows_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+require_relative 'test_helper'
+require 'mocha/minitest'
+
+module Dynflow
+  describe 'flow' do
+
+    class TestRegistry < Flows::Registry
+      class << self
+        def reset!
+          @serialization_map = {}
+        end
+      end
+    end
+
+    after do
+      TestRegistry.reset!
+    end
+
+    describe "registry" do
+      it "allows registering values" do
+        TestRegistry.register!(TestRegistry, 'TS')
+        TestRegistry.register!(Integer, 'I')
+        map = TestRegistry.instance_variable_get("@serialization_map")
+        _(map).must_equal({'TS' => TestRegistry, 'I' => Integer})
+      end
+
+      it "prevents overwriting values" do
+        TestRegistry.register!(Integer, 'I')
+        _(-> { TestRegistry.register!(Float, 'I') }).must_raise Flows::Registry::IdentifierTaken
+      end
+
+      it "encodes and decodes values" do
+        TestRegistry.register!(Integer, 'I')
+        _(TestRegistry.encode(Integer)).must_equal 'I'
+      end
+
+      it "raises an exception when unknown key is requested" do
+        _(-> { TestRegistry.encode(Float) }).must_raise Flows::Registry::UnknownIdentifier
+        _(-> { TestRegistry.decode('F') }).must_raise Flows::Registry::UnknownIdentifier
+      end
+    end
+  end
+end

data/test/future_execution_test.rb

@@ -55,7 +55,7 @@ module Dynflow
 
         it 'delays the action' do
           _(execution_plan.steps.count).must_equal 1
-          _(delayed_plan.start_at.inspect).must_equal (@start_at).inspect
+          _(delayed_plan.start_at).must_be_within_delta(@start_at, 0.5)
           _(history_names.call(execution_plan)).must_equal ['delay']
         end
 

data/test/persistence_test.rb

@@ -86,7 +86,7 @@ module Dynflow
         original.each do |key, value|
           loaded_value = loaded[key.to_s]
           if value.is_a?(Time)
-            _(loaded_value.inspect).must_equal value.inspect
+            _(loaded_value).must_be_within_delta(value, 0.5)
           elsif value.is_a?(Hash)
             assert_equal_attributes!(value, loaded_value)
           elsif value.nil?
@@ -348,7 +348,7 @@ module Dynflow
               if value.nil?
                 assert_nil stored.fetch(name.to_sym)
               elsif value.is_a?(Time)
-                _(stored.fetch(name.to_sym).inspect).must_equal value.inspect
+                _(stored.fetch(name.to_sym)).must_be_within_delta(value, 0.5)
               else
                 _(stored.fetch(name.to_sym)).must_equal value
               end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 1.4.7
+  version: 1.5.0
 platform: ruby
 authors:
 - Ivan Necas
 - Petr Chalupa
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1970-01-01 00:00:00.000000000 Z
+date: 2021-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -242,10 +242,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/install_dependencies.sh"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
-- ".travis.yml"
 - Dockerfile
 - Gemfile
 - MIT-LICENSE
@@ -474,6 +475,7 @@ files:
 - lib/dynflow/flows/abstract_composed.rb
 - lib/dynflow/flows/atom.rb
 - lib/dynflow/flows/concurrence.rb
+- lib/dynflow/flows/registry.rb
 - lib/dynflow/flows/sequence.rb
 - lib/dynflow/logger_adapters.rb
 - lib/dynflow/logger_adapters/abstract.rb
@@ -576,11 +578,11 @@ files:
 - test/execution_plan_hooks_test.rb
 - test/execution_plan_test.rb
 - test/executor_test.rb
+- test/flows_test.rb
 - test/future_execution_test.rb
 - test/memory_cosumption_watcher_test.rb
 - test/middleware_test.rb
 - test/persistence_test.rb
-- test/prepare_travis_env.sh
 - test/redis_locking_test.rb
 - test/rescue_test.rb
 - test/round_robin_test.rb
@@ -625,7 +627,7 @@ homepage: https://github.com/Dynflow/dynflow
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -641,7 +643,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: DYNamic workFLOW engine
 test_files:
@@ -659,11 +661,11 @@ test_files:
 - test/execution_plan_hooks_test.rb
 - test/execution_plan_test.rb
 - test/executor_test.rb
+- test/flows_test.rb
 - test/future_execution_test.rb
 - test/memory_cosumption_watcher_test.rb
 - test/middleware_test.rb
 - test/persistence_test.rb
-- test/prepare_travis_env.sh
 - test/redis_locking_test.rb
 - test/rescue_test.rb
 - test/round_robin_test.rb

data/.travis.yml

@@ -1,33 +0,0 @@
-language: ruby
-
-services:
-  - postgresql
-  - redis
-
-rvm:
-  - "2.3.1"
-  - "2.4.0"
-  - "2.5.0"
-
-env:
-  global:
-    - "TESTOPTS=--verbose DB=postgresql DB_CONN_STRING=postgres://postgres@localhost/travis_ci_test"
-
-matrix:
-  include:
-    - rvm: "2.4.0"
-      env: "DB=mysql DB_CONN_STRING=mysql2://root@localhost/travis_ci_test"
-      services:
-        - mysql
-        - redis
-    - rvm: "2.4.0"
-      env: "DB=sqlite3 DB_CONN_STRING=sqlite:/"
-    - rvm: "2.4.0"
-      env: "CONCURRENT_RUBY_EXT=true"
-
-install:
-  - test/prepare_travis_env.sh
-
-script:
-  - bundle exec rubocop
-  - bundle exec rake test