dynflow 0.8.3 → 0.8.4

data/lib/dynflow/execution_plan/output_reference.rb

@@ -6,7 +6,7 @@ module Dynflow
     def self.dereference(object, persistence)
       case object
       when Hash
-        object.reduce(HashWithIndifferentAccess.new) do |h, (key, val)|
+        object.reduce(Utils.indifferent_hash({})) do |h, (key, val)|
           h.update(key => dereference(val, persistence))
         end
       when Array
@@ -25,7 +25,7 @@ module Dynflow
         if value[:class] == self.to_s
           new_from_hash(value)
         else
-          value.reduce(HashWithIndifferentAccess.new) do |h, (key, val)|
+          value.reduce(Utils.indifferent_hash({})) do |h, (key, val)|
             h.update(key => deserialize(val))
           end
         end

data/lib/dynflow/execution_plan/steps/error.rb

@@ -32,7 +32,7 @@ module Dynflow
 
       def self.new_from_hash(hash)
         exception_class = begin
-                            hash[:exception_class].constantize
+                            Utils.constantize(hash[:exception_class])
                           rescue NameError
                             Errors::UnknownError.for_exception_class(hash[:exception_class])
                           end

data/lib/dynflow/execution_plan/steps/plan_step.rb

@@ -35,8 +35,8 @@ module Dynflow
         super.merge recursive_to_hash(:children => children)
       end
 
-      def schedule(schedule_options, args)
-        @action.execute_schedule(schedule_options, *args)
+      def delay(delay_options, args)
+        @action.execute_delay(delay_options, *args)
         @action.serializer
       ensure
         save

data/lib/dynflow/middleware.rb

@@ -21,7 +21,7 @@ module Dynflow
       @stack.action or raise "the action is not available"
     end
 
-    def schedule(*args)
+    def delay(*args)
       pass(*args)
     end
 

data/lib/dynflow/middleware/stack.rb

@@ -14,7 +14,7 @@ module Dynflow
       @middleware_class = Child! middleware_class, Middleware
       @middleware       = middleware_class.new self
       @action           = Type! action, Dynflow::Action, NilClass
-      @method           = Match! method, :schedule, :plan, :run, :finalize, :plan_phase, :finalize_phase
+      @method           = Match! method, :delay, :plan, :run, :finalize, :plan_phase, :finalize_phase
       @next_stack       = Type! next_stack, Middleware::Stack, Proc
     end
 

data/lib/dynflow/middleware/world.rb

@@ -14,7 +14,7 @@ module Dynflow
     end
 
     def execute(method, action_or_class, *args, &block)
-      Match! method, :schedule, :plan, :run, :finalize, :plan_phase, :finalize_phase
+      Match! method, :delay, :plan, :run, :finalize, :plan_phase, :finalize_phase
       if Child? action_or_class, Dynflow::Action
         action = nil
         action_class = action_or_class

data/lib/dynflow/persistence.rb

@@ -49,24 +49,24 @@ module Dynflow
       adapter.save_execution_plan(execution_plan.id, execution_plan.to_hash)
     end
 
-    def find_past_scheduled_plans(time)
-      adapter.find_past_scheduled_plans(time).map do |plan|
-        ScheduledPlan.new_from_hash(@world, plan)
+    def find_past_delayed_plans(time)
+      adapter.find_past_delayed_plans(time).map do |plan|
+        DelayedPlan.new_from_hash(@world, plan)
       end
     end
 
-    def delete_scheduled_plans(filters, batch_size = 1000)
-      adapter.delete_scheduled_plans(filters, batch_size)
+    def delete_delayed_plans(filters, batch_size = 1000)
+      adapter.delete_delayed_plans(filters, batch_size)
     end
 
-    def save_scheduled_plan(schedule)
-      adapter.save_scheduled_plan(schedule.execution_plan_uuid, schedule.to_hash)
+    def save_delayed_plan(delayed_plan)
+      adapter.save_delayed_plan(delayed_plan.execution_plan_uuid, delayed_plan.to_hash)
     end
 
-    def load_scheduled_plan(execution_plan_id)
-      hash = adapter.load_scheduled_plan(execution_plan_id)
+    def load_delayed_plan(execution_plan_id)
+      hash = adapter.load_delayed_plan(execution_plan_id)
       return nil unless hash
-      ScheduledPlan.new_from_hash(@world, hash)
+      DelayedPlan.new_from_hash(@world, hash)
     end
 
     def load_step(execution_plan_id, step_id, world)

data/lib/dynflow/persistence_adapters/abstract.rb

@@ -55,19 +55,19 @@ module Dynflow
         raise NotImplementedError
       end
 
-      def find_past_scheduled_plans(options = {})
+      def find_past_delayed_plans(options = {})
         raise NotImplementedError
       end
 
-      def delete_scheduled_plans(filters, batch_size = 1000)
+      def delete_delayed_plans(filters, batch_size = 1000)
         raise NotImplementedError
       end
 
-      def load_scheduled_plan(execution_plan_id)
+      def load_delayed_plan(execution_plan_id)
         raise NotImplementedError
       end
 
-      def save_scheduled_plan(execution_plan_id, value)
+      def save_delayed_plan(execution_plan_id, value)
         raise NotImplementedError
       end
 

data/lib/dynflow/persistence_adapters/sequel.rb

@@ -32,7 +32,7 @@ module Dynflow
                     step:                %w(state started_at ended_at real_time execution_time action_id progress_done progress_weight),
                     envelope:            %w(receiver_id),
                     coordinator_record:  %w(id owner_id class),
-                    scheduled:           %w(execution_plan_uuid start_at start_before args_serializer)}
+                    delayed:             %w(execution_plan_uuid start_at start_before args_serializer)}
 
       def initialize(config)
         config = config.dup
@@ -63,7 +63,7 @@ module Dynflow
         filter(:execution_plan, table(:execution_plan), filters).each_slice(batch_size) do |plans|
           uuids = plans.map { |p| p.fetch(:uuid) }
           @db.transaction do
-            table(:scheduled).where(execution_plan_uuid: uuids).delete
+            table(:delayed).where(execution_plan_uuid: uuids).delete
             table(:step).where(execution_plan_uuid: uuids).delete
             table(:action).where(execution_plan_uuid: uuids).delete
             count += table(:execution_plan).where(uuid: uuids).delete
@@ -80,33 +80,33 @@ module Dynflow
         save :execution_plan, { uuid: execution_plan_id }, value
       end
 
-      def delete_scheduled_plans(filters, batch_size = 1000)
+      def delete_delayed_plans(filters, batch_size = 1000)
         count = 0
-        filter(:scheduled, table(:scheduled), filters).each_slice(batch_size) do |plans|
+        filter(:delayed, table(:delayed), filters).each_slice(batch_size) do |plans|
           uuids = plans.map { |p| p.fetch(:execution_plan_uuid) }
           @db.transaction do
-            count += table(:scheduled).where(execution_plan_uuid: uuids).delete
+            count += table(:delayed).where(execution_plan_uuid: uuids).delete
           end
         end
         count
       end
 
-      def find_past_scheduled_plans(time)
-        table(:scheduled)
+      def find_past_delayed_plans(time)
+        table(:delayed)
           .where('start_at <= ?', time)
           .order_by(:start_at)
           .all
           .map { |plan| load_data(plan) }
       end
 
-      def load_scheduled_plan(execution_plan_id)
-        load :scheduled, execution_plan_uuid: execution_plan_id
+      def load_delayed_plan(execution_plan_id)
+        load :delayed, execution_plan_uuid: execution_plan_id
       rescue KeyError
         return nil
       end
 
-      def save_scheduled_plan(execution_plan_id, value)
-        save :scheduled, { execution_plan_uuid: execution_plan_id }, value
+      def save_delayed_plan(execution_plan_id, value)
+        save :delayed, { execution_plan_uuid: execution_plan_id }, value
       end
 
       def load_step(execution_plan_id, step_id)
@@ -195,7 +195,7 @@ module Dynflow
                  step:                :dynflow_steps,
                  envelope:            :dynflow_envelopes,
                  coordinator_record:  :dynflow_coordinator_records,
-                 scheduled:           :dynflow_scheduled_plans }
+                 delayed:             :dynflow_delayed_plans }
 
       def table(which)
         db[TABLES.fetch(which)]
@@ -243,7 +243,7 @@ module Dynflow
 
       def load(what, condition)
         table = table(what)
-        if (record = with_retry { table.first(condition.symbolize_keys) } )
+        if (record = with_retry { table.first(Utils.symbolize_keys(condition)) } )
           load_data(record)
         else
           raise KeyError, "searching: #{what} by: #{condition.inspect}"
@@ -251,16 +251,16 @@ module Dynflow
       end
 
       def load_data(record)
-        HashWithIndifferentAccess.new(MultiJson.load(record[:data]))
+        Utils.indifferent_hash(MultiJson.load(record[:data]))
       end
 
       def delete(what, condition)
-        table(what).where(condition.symbolize_keys).delete
+        table(what).where(Utils.symbolize_keys(condition)).delete
       end
 
       def extract_metadata(what, value)
         meta_keys = META_DATA.fetch(what)
-        value         = value.with_indifferent_access
+        value         = Utils.indifferent_hash(value)
         meta_keys.inject({}) { |h, k| h.update k.to_sym => value[k] }
       end
 
@@ -312,7 +312,7 @@ module Dynflow
           raise ArgumentError, "unkown columns: #{unknown.inspect}"
         end
 
-        data_set.where filters.symbolize_keys
+        data_set.where Utils.symbolize_keys(filters)
       end
 
       def with_retry

data/lib/dynflow/persistence_adapters/sequel_migrations/008_rename_scheduled_plans_to_delayed_plans.rb

@@ -0,0 +1,5 @@
+Sequel.migration do
+  change do
+    rename_table(:dynflow_scheduled_plans, :dynflow_delayed_plans)
+  end
+end

data/lib/dynflow/serializable.rb

@@ -27,7 +27,7 @@ module Dynflow
     end
 
     def self.constantize(action_name)
-      action_name.constantize
+      Utils.constantize(action_name)
     end
 
     private_class_method :check_class_matching, :check_class_key_present

data/lib/dynflow/serializer.rb

@@ -19,7 +19,7 @@ module Dynflow
         end
 
         if (type_name = other[ARBITRARY_TYPE_KEY] || other[ARBITRARY_TYPE_KEY.to_s])
-          type = type_name.constantize rescue nil
+          type = Utils.constantize(type_name) rescue nil
           if type && type.respond_to?(:from_hash)
             return type.from_hash other
           end

data/lib/dynflow/testing/assertions.rb

@@ -49,7 +49,7 @@ module Dynflow
         Match! action.phase, Action::Plan
         Match! action.state, :success
         action.execution_plan.planned_run_steps.must_include action
-        action.input.must_equal input.stringify_keys if input
+        action.input.must_equal Utils.stringify_keys(input) if input
         block.call action.input if block
       end
 

data/lib/dynflow/utils.rb

@@ -0,0 +1,205 @@
+module Dynflow
+  module Utils
+
+    def self.symbolize_keys(hash)
+      return hash.symbolize_keys if hash.respond_to?(:symbolize_keys)
+      hash.reduce({}) do |new_hash, (key, value)|
+        new_hash.update(key.to_sym => value)
+      end
+    end
+
+    def self.stringify_keys(hash)
+      return hash.stringify_keys if hash.respond_to?(:stringify_keys)
+      hash.reduce({}) do |new_hash, (key, value)|
+        new_hash.update(key.to_s => value)
+      end
+    end
+
+    # Inspired by ActiveSupport::Inflector
+    def self.constantize(string)
+      return string.constantize if string.respond_to?(:constantize)
+
+      names = string.split('::')
+
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
+      Object.const_get(string) if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+
+    def self.indifferent_hash(hash)
+      if defined? ::HashWithIndifferentAccess
+        # the users already have it: lets give them what they are used to
+        ::HashWithIndifferentAccess.new(hash)
+      else
+        if hash.is_a? IndifferentHash
+          return hash
+        else
+          IndifferentHash.new(hash)
+        end
+      end
+    end
+
+    # Heaviliy inpired by ActiveSupport::HashWithIndifferentAccess,
+    # reasons we don't want to use the original implementation:
+    #   1. we don't want any core_ext extensions
+    #   2. some users are not happy about seeing the ActiveSupport as
+    #   our depednency
+    class IndifferentHash < Hash
+      def initialize(constructor = {})
+        if constructor.respond_to?(:to_hash)
+          super()
+          update(constructor)
+        else
+          super(constructor)
+        end
+      end
+
+      def default(key = nil)
+        if key.is_a?(Symbol) && include?(key = key.to_s)
+          self[key]
+        else
+          super
+        end
+      end
+
+      def self.[](*args)
+        new.merge!(Hash[*args])
+      end
+
+      alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+      alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+      def []=(key, value)
+        regular_writer(convert_key(key), convert_value(value, for: :assignment))
+      end
+
+      alias_method :store, :[]=
+
+      def update(other_hash)
+        if other_hash.is_a? IndifferentHash
+          super(other_hash)
+        else
+          other_hash.to_hash.each_pair do |key, value|
+            if block_given? && key?(key)
+              value = yield(convert_key(key), self[key], value)
+            end
+            regular_writer(convert_key(key), convert_value(value))
+          end
+          self
+        end
+      end
+
+      alias_method :merge!, :update
+
+      def key?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :include?, :key?
+      alias_method :has_key?, :key?
+      alias_method :member?, :key?
+
+      def fetch(key, *extras)
+        super(convert_key(key), *extras)
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      def dup
+        self.class.new(self).tap do |new_hash|
+          new_hash.default = default
+        end
+      end
+
+      def merge(hash, &block)
+        self.dup.update(hash, &block)
+      end
+
+      def reverse_merge(other_hash)
+        super(self.class.new_from_hash_copying_default(other_hash))
+      end
+
+      def reverse_merge!(other_hash)
+        replace(reverse_merge( other_hash ))
+      end
+
+      def replace(other_hash)
+        super(self.class.new_from_hash_copying_default(other_hash))
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def stringify_keys!; self end
+      def deep_stringify_keys!; self end
+      def stringify_keys; dup end
+      def deep_stringify_keys; dup end
+      def to_options!; self end
+
+      def select(*args, &block)
+        dup.tap { |hash| hash.select!(*args, &block) }
+      end
+
+      def reject(*args, &block)
+        dup.tap { |hash| hash.reject!(*args, &block) }
+      end
+
+      # Convert to a regular hash with string keys.
+      def to_hash
+        _new_hash = Hash.new(default)
+        each do |key, value|
+          _new_hash[key] = convert_value(value, for: :to_hash)
+        end
+        _new_hash
+      end
+
+      protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value, options = {})
+        if value.is_a? Hash
+          if options[:for] == :to_hash
+            value.to_hash
+          else
+            Utils.indifferent_hash(value)
+          end
+        elsif value.is_a?(Array)
+          unless options[:for] == :assignment
+            value = value.dup
+          end
+          value.map! { |e| convert_value(e, options) }
+        else
+          value
+        end
+      end
+    end
+  end
+end