dynflow 0.1.0 → 0.2.0

data/lib/dynflow/persistence_adapters/sequel.rb

@@ -0,0 +1,160 @@
+require 'sequel/no_core_ext' # to avoid sequel ~> 3.0 coliding with ActiveRecord
+require 'multi_json'
+
+module Dynflow
+  module PersistenceAdapters
+
+    Sequel.extension :migration
+
+    class Sequel < Abstract
+      include Algebrick::TypeCheck
+
+      attr_reader :db
+
+      def pagination?
+        true
+      end
+
+      def filtering_by
+        META_DATA.fetch :execution_plan
+      end
+
+      def ordering_by
+        META_DATA.fetch :execution_plan
+      end
+
+      META_DATA = { execution_plan: %w(state result started_at ended_at real_time execution_time),
+                    action:         [],
+                    step:           %w(state started_at ended_at real_time execution_time action_id) }
+
+      def initialize(db_path)
+        @db = initialize_db db_path
+        migrate_db
+      end
+
+      def find_execution_plans(options = {})
+        data_set = filter(order(paginate(table(:execution_plan), options), options), options)
+
+        data_set.map do |record|
+          HashWithIndifferentAccess.new(MultiJson.load(record[:data]))
+        end
+      end
+
+      def load_execution_plan(execution_plan_id)
+        load :execution_plan, uuid: execution_plan_id
+      end
+
+      def save_execution_plan(execution_plan_id, value)
+        save :execution_plan, { uuid: execution_plan_id }, value
+      end
+
+      def load_step(execution_plan_id, step_id)
+        load :step, execution_plan_uuid: execution_plan_id, id: step_id
+      end
+
+      def save_step(execution_plan_id, step_id, value)
+        save :step, { execution_plan_uuid: execution_plan_id, id: step_id }, value
+      end
+
+      def load_action(execution_plan_id, action_id)
+        load :action, execution_plan_uuid: execution_plan_id, id: action_id
+      end
+
+      def save_action(execution_plan_id, action_id, value)
+        save :action, { execution_plan_uuid: execution_plan_id, id: action_id }, value
+      end
+
+      def to_hash
+        { execution_plans: table(:execution_plan).all,
+          steps:           table(:step).all,
+          actions:         table(:action).all }
+      end
+
+      private
+
+      TABLES = { execution_plan: :dynflow_execution_plans,
+                 action:         :dynflow_actions,
+                 step:           :dynflow_steps }
+
+      def table(which)
+        db[TABLES.fetch(which)]
+      end
+
+      def initialize_db(db_path)
+        ::Sequel.connect db_path
+      end
+
+      def self.migrations_path
+        File.expand_path('../sequel_migrations', __FILE__)
+      end
+
+      def migrate_db
+        ::Sequel::Migrator.run(db, self.class.migrations_path, table: 'dynflow_schema_info')
+      end
+
+      def save(what, condition, value)
+        table           = table(what)
+        existing_record = table.first condition
+
+        if value
+          value         = value.with_indifferent_access
+          record        = existing_record || condition
+          record[:data] = MultiJson.dump Type!(value, Hash)
+          meta_data     = META_DATA.fetch(what).inject({}) { |h, k| h.update k.to_sym => value.fetch(k) }
+          record.merge! meta_data
+          record.each { |k, v| record[k] = v.to_s if v.is_a? Symbol }
+
+          if existing_record
+            table.where(condition).update(record)
+          else
+            table.insert record
+          end
+
+        else
+          existing_record and table.where(condition).delete
+        end
+        value
+      end
+
+      def load(what, condition)
+        table = table(what)
+        if (record = table.first(condition.symbolize_keys))
+          HashWithIndifferentAccess.new MultiJson.load(record[:data])
+        else
+          raise KeyError, "searching: #{what} by: #{condition.inspect}"
+        end
+      end
+
+      def paginate(data_set, options)
+        page     = Integer(options[:page] || 0)
+        per_page = Integer(options[:per_page] || 20)
+
+        if page
+          data_set.limit per_page, per_page * page
+        else
+          data_set
+        end
+      end
+
+      def order(data_set, options)
+        order_by = (options[:order_by] || :started_at).to_s
+        unless META_DATA.fetch(:execution_plan).include? order_by
+          raise ArgumentError, "unknown column #{order_by.inspect}"
+        end
+        order_by = order_by.to_sym
+        data_set.order_by options[:desc] ? ::Sequel.desc(order_by) : order_by
+      end
+
+      def filter(data_set, options)
+        filters = Type! options[:filters], NilClass, Hash
+        return data_set if filters.nil?
+
+        unless (unknown = filters.keys - META_DATA.fetch(:execution_plan)).empty?
+          raise ArgumentError, "unkown columns: #{unknown.inspect}"
+        end
+
+        data_set.where filters.symbolize_keys
+      end
+    end
+  end
+end

data/lib/dynflow/persistence_adapters/sequel_migrations/001_initial.rb

@@ -0,0 +1,52 @@
+Sequel.migration do
+  up do
+    create_table(:dynflow_execution_plans) do
+      column :uuid, String, primary_key: true, size: 36, fixed: true
+      index :uuid, :unique => true
+
+      column :data, String, text: true
+
+      column :state, String
+      column :result, String
+      column :started_at, Time
+      column :ended_at, Time
+      column :real_time, Float
+      column :execution_time, Float
+    end
+
+    create_table(:dynflow_actions) do
+      foreign_key :execution_plan_uuid, :dynflow_execution_plans, type: String, size: 36, fixed: true
+      index :execution_plan_uuid
+      column :id, Fixnum
+      primary_key [:execution_plan_uuid, :id]
+      index [:execution_plan_uuid, :id], :unique => true
+
+      column :data, String, text: true
+    end
+
+    create_table(:dynflow_steps) do
+      foreign_key :execution_plan_uuid, :dynflow_execution_plans, type: String, size: 36, fixed: true
+      index :execution_plan_uuid
+      column :id, Fixnum
+      primary_key [:execution_plan_uuid, :id]
+      index [:execution_plan_uuid, :id], :unique => true
+      column :action_id, Fixnum
+      foreign_key [:execution_plan_uuid, :action_id], :dynflow_actions
+      index [:execution_plan_uuid, :action_id]
+
+      column :data, String, text: true
+
+      column :state, String
+      column :started_at, Time
+      column :ended_at, Time
+      column :real_time, Float
+      column :execution_time, Float
+    end
+  end
+
+  down do
+    drop_table(:dynflow_steps)
+    drop_table(:dynflow_actions)
+    drop_table(:dynflow_execution_plans)
+  end
+end

data/lib/dynflow/serializable.rb

@@ -0,0 +1,66 @@
+module Dynflow
+  class Serializable
+    def self.from_hash(hash, *args)
+      check_class_key_present hash
+      hash[:class].constantize.new_from_hash(hash, *args)
+    end
+
+    def to_hash
+      raise NotImplementedError
+    end
+
+    # @api private
+    def self.new_from_hash(hash, *args)
+      raise NotImplementedError
+      # new ...
+    end
+
+    def self.check_class_matching(hash)
+      check_class_key_present hash
+      unless self.to_s == hash[:class]
+        raise ArgumentError, "class mismatch #{hash[:class]} != #{self}"
+      end
+    end
+
+    def self.check_class_key_present(hash)
+      raise ArgumentError, 'missing :class' unless hash[:class]
+    end
+
+    private_class_method :check_class_matching, :check_class_key_present
+
+    private
+
+    def recursive_to_hash(value)
+      case value
+      when Numeric, String, Symbol, TrueClass, FalseClass, NilClass
+        value
+      when Array
+        value.map { |v| recursive_to_hash v }
+      when Hash
+        value.inject({}) { |h, (k, v)| h.update k => recursive_to_hash(v) }
+      else
+        value.to_hash
+      end
+    end
+
+    def self.string_to_time(string)
+      return if string.nil?
+      _, year, month, day, hour, min, sec = */(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/.match(string)
+      Time.new(year.to_i, month.to_i, day.to_i, hour.to_i, min.to_i, sec.to_i)
+    end
+
+    def time_to_str(time)
+      return if time.nil?
+      Type! time, Time
+      time.strftime '%Y-%m-%d %H:%M:%S'
+    end
+
+    def self.hash_to_error(hash)
+      return nil if hash.nil?
+      ExecutionPlan::Steps::Error.from_hash(hash)
+    end
+
+    private_class_method :string_to_time, :hash_to_error
+
+  end
+end

data/lib/dynflow/simple_world.rb

@@ -0,0 +1,18 @@
+module Dynflow
+  class SimpleWorld < World
+    def initialize(options_hash = {})
+      super options_hash
+      at_exit { self.terminate.wait } if options[:auto_terminate]
+      # we can check consistency here because SimpleWorld doesn't expect
+      # remote executor being in place.
+      self.consistency_check
+    end
+
+    def default_options
+      super.merge(pool_size:           5,
+                  persistence_adapter: PersistenceAdapters::Sequel.new('sqlite:/'),
+                  transaction_adapter: TransactionAdapters::None.new,
+                  auto_terminate:      true)
+    end
+  end
+end

data/lib/dynflow/stateful.rb

@@ -0,0 +1,40 @@
+module Dynflow
+  module Stateful
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def states
+        raise NotImplementedError
+      end
+
+      def state_transitions
+        raise NotImplementedError
+      end
+    end
+
+    def states
+      self.class.states
+    end
+
+    def state_transitions
+      self.class.state_transitions
+    end
+
+    attr_reader :state
+
+    def state=(state)
+      set_state state, false
+    end
+
+    def set_state(state, skip_transition_check)
+      state = state.to_sym if state.is_a?(String) && states.map(&:to_s).include?(state)
+      raise "unknown state #{state}" unless states.include? state
+      unless self.state.nil? || skip_transition_check || state_transitions.fetch(self.state).include?(state)
+        raise "invalid state transition #{self.state} >> #{state} in #{self}"
+      end
+      @state = state
+    end
+  end
+end

data/lib/dynflow/testing.rb

@@ -0,0 +1,32 @@
+module Dynflow
+  module Testing
+    extend Algebrick::TypeCheck
+
+    def self.logger_adapter
+      @logger_adapter ||= LoggerAdapters::Simple.new $stdout, 0
+    end
+
+    def self.logger_adapter=(adapter)
+      Type! adapter, LoggerAdapters::Abstract
+      @logger_adapter = adapter
+    end
+
+    def self.get_id
+      @last_id ||= 0
+      @last_id += 1
+    end
+
+    require 'dynflow/testing/mimic'
+    require 'dynflow/testing/managed_clock'
+    require 'dynflow/testing/dummy_world'
+    require 'dynflow/testing/dummy_executor'
+    require 'dynflow/testing/dummy_execution_plan'
+    require 'dynflow/testing/dummy_step'
+    require 'dynflow/testing/dummy_planned_action'
+    require 'dynflow/testing/assertions'
+    require 'dynflow/testing/factories'
+
+    include Assertions
+    include Factories
+  end
+end

data/lib/dynflow/testing/assertions.rb

@@ -0,0 +1,64 @@
+module Dynflow
+  module Testing
+    module Assertions
+      # assert that +assert_actioned_plan+ was planned by +action+ with arguments +plan_input+
+      # alternatively plan-input can be asserted with +block+
+      def assert_action_planed_with(action, planned_action_class, *plan_input, &block)
+        found_classes = assert_action_planed(action, planned_action_class)
+        found         = found_classes.select do |a|
+          if plan_input.empty?
+            block.call a.plan_input
+          else
+            a.plan_input == plan_input
+          end
+        end
+
+        assert(!found.empty?,
+               "Action #{planned_action_class} with plan_input #{plan_input} was not planned, there were only #{found_classes.map(&:plan_input)}")
+        found
+      end
+
+      # assert that +assert_actioned_plan+ was planned by +action+
+      def assert_action_planed(action, planned_action_class)
+        Type! action, Dynflow::Action::PlanPhase
+        Match! action.state, :success
+        found = action.execution_plan.planned_plan_steps.
+            select { |a| a.is_a?(planned_action_class) }
+
+        assert(!found.empty?, "Action #{planned_action_class} was not planned")
+        found
+      end
+
+      # assert that +action+ has run-phase planned
+      def assert_run_phase(action, input = nil, &block)
+        Type! action, Dynflow::Action::PlanPhase
+        Match! action.state, :success
+        action.execution_plan.planned_run_steps.must_include action
+        action.input.must_equal input.stringify_keys if input
+        block.call input if block
+      end
+
+      # refute that +action+ has run-phase planned
+      def refute_run_phase(action)
+        Type! action, Dynflow::Action::PlanPhase
+        Match! action.state, :success
+        action.execution_plan.planned_run_steps.wont_include action
+      end
+
+      # assert that +action+ has finalize-phase planned
+      def assert_finalize_phase(action)
+        Type! action, Dynflow::Action::PlanPhase
+        Match! action.state, :success
+        action.execution_plan.planned_finalize_steps.must_include action
+      end
+
+      # refute that +action+ has finalize-phase planned
+      def refute_finalize_phase(action)
+        Type! action, Dynflow::Action::PlanPhase
+        Match! action.state, :success
+        action.execution_plan.planned_finalize_steps.wont_include action
+      end
+
+    end
+  end
+end

data/lib/dynflow/testing/dummy_execution_plan.rb

@@ -0,0 +1,40 @@
+module Dynflow
+  module Testing
+    class DummyExecutionPlan
+      extend Mimic
+      mimic! ExecutionPlan
+
+      attr_reader :id, :planned_plan_steps, :planned_run_steps, :planned_finalize_steps
+
+      def initialize
+        @id                     = Testing.get_id
+        @planned_plan_steps     = []
+        @planned_run_steps      = []
+        @planned_finalize_steps = []
+      end
+
+      def world
+        @world ||= DummyWorld.new
+      end
+
+      def add_run_step(action)
+        @planned_run_steps << action
+        action
+      end
+
+      def add_finalize_step(action)
+        @planned_finalize_steps << action
+        action
+      end
+
+      def add_plan_step(klass, action)
+        @planned_plan_steps << action = DummyPlannedAction.new(klass)
+        action
+      end
+
+      def switch_flow(*args, &block)
+        block.call
+      end
+    end
+  end
+end