libis-workflow-activerecord 0.9.0

data/lib/libis/workflow/activerecord/base.rb

@@ -0,0 +1,79 @@
+require 'yaml'
+require 'libis/tools/extend/hash'
+
+module Libis
+  module Workflow
+    module ActiveRecord
+
+      module Base
+
+        def self.included(klass)
+          klass.extend(ClassMethods)
+
+          # def [](key)
+          #   self.send(key.to_sym)
+          # end
+          #
+          # def []=(key,value)
+          #   self.send(key.to_s + '=', value)
+          # end
+        end
+
+        module ClassMethods
+          def from_hash(hash)
+            self.create_from_hash(hash.cleanup, [:name])
+          end
+
+          def create_from_hash(hash, id_tags, &block)
+            hash = hash.key_symbols_to_strings(recursive: true)
+            id_tags = id_tags.map(&:to_s)
+            return nil unless id_tags.empty? || id_tags.any? { |k| hash.include?(k) }
+            tags = id_tags.inject({}) do |h, k|
+              v = hash.delete(k)
+              h[k] = v if v
+              h
+            end
+            item = tags.empty? ? self.new : self.find_or_initialize_by(tags)
+            block.call(item, hash) if block unless hash.empty?
+            item.assign_attributes(hash)
+            item.save!
+            item
+          end
+
+        end
+
+        def to_hash
+          result = self.attributes.reject { |k, v| v.blank? || volatile_attributes.include?(k) }
+          result = result.to_yaml
+          # noinspection RubyResolve
+          YAML.load(result)
+        end
+
+        def to_s
+          self.name || "#{self.class.name}_#{self.id}"
+        end
+
+        protected
+
+        def volatile_attributes
+          %w'id created_at updated_at'
+        end
+
+        private
+
+        def copy_attributes(other)
+          self.set(
+              other.attributes.reject do |k, _|
+                volatile_attributes.include? k.to_s
+              end.each_with_object({}) do |(k, v), h|
+                h[k] = v.duplicable? ? v.dup : v
+              end
+          )
+          self
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/workflow/activerecord/config.rb

@@ -0,0 +1,30 @@
+# noinspection RubyResolve
+require 'singleton'
+require 'active_record'
+
+require 'libis/workflow/base/logging'
+
+require 'libis/workflow/config'
+module Libis
+  module Workflow
+    module ActiveRecord
+
+      # noinspection RubyConstantNamingConvention
+      Config = ::Libis::Workflow::Config
+
+      Config.define_singleton_method(:database_connect) do |config_file = 'db/config.yml', environment = :production|
+        # noinspection RubyResolve
+        instance.database_connect(config_file, environment)
+      end
+
+      Config.send(:define_method, :database_connect) do |config_file = 'db/config.yml', environment = :production|
+	      db_config = YAML.load_file(config_file)
+        # ::ActiveRecord::Base.logger = Libis::Workflow::ActiveRecord::Config.logger
+        ::ActiveRecord::Base.establish_connection(db_config[environment.to_s])
+      end
+
+      Config[:log_dir] = '.'
+
+    end
+  end
+end

data/lib/libis/workflow/activerecord/helpers/hash_serializer.rb

@@ -0,0 +1,32 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'libis/tools/extend/hash'
+
+module Libis
+  module Workflow
+    module ActiveRecord
+      module Helpers
+
+        class HashSerializer
+
+          def self.dump(hash)
+            delete_proc = Proc.new do |_, v|
+              # Cleanup the hash recursively and remove entries with value == nil
+              # noinspection RubyScope
+              v.delete_if(&delete_proc) if v.kind_of?(Hash)
+              v.nil?
+            end
+            hash.delete_if &delete_proc if hash.is_a?(Hash)
+            # Store a nil value if the hash is empty
+            (hash.is_a?(Hash) && !hash.empty?) ? hash : nil
+          end
+
+          def self.load(hash)
+            (hash || {}).with_indifferent_access
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/workflow/activerecord/helpers/property_helper.rb

@@ -0,0 +1,40 @@
+require 'yaml'
+
+module Libis
+  module Workflow
+    module ActiveRecord
+      module Helpers
+
+        module PropertyHelper
+          def self.included(klass)
+            klass.extend(ClassMethods)
+          end
+
+          module ClassMethods
+
+            def property_field(name, options = {})
+              default = options[:default]
+              default = default.call if default.is_a? Proc
+              if options[:type]
+                # noinspection RubyResolve
+                options.reverse_merge! reader: lambda {|value| value.blank? ? nil : YAML.load(value)},
+                                       writer: lambda {|value| value ? YAML.dump(value) : nil}
+              end
+              self.send(:define_method, name, lambda {
+                value = properties[name]
+                (options[:reader] ? options[:reader].call(value) : value) || default
+              })
+              self.send(:define_method, "#{name}=", lambda {|value|
+                value ||= default
+                properties[name] = options[:writer] ? options[:writer].call(value) : value
+              })
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/workflow/activerecord/helpers/status_serializer.rb

@@ -0,0 +1,30 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Libis
+  module Workflow
+    module ActiveRecord
+      module Helpers
+
+        class StatusSerializer
+
+          def self.dump(array)
+            return nil unless array.is_a?(Array) && !array.empty?
+            array || []
+          end
+
+          def self.load(array)
+            (array || []).map do |status|
+              status = status.with_indifferent_access
+              status[:status] = status[:status].to_sym if status.has_key? :status
+              status[:created] = DateTime.parse(status[:created]) if status.has_key? :created
+              status[:updated] = DateTime.parse(status[:updated]) if status.has_key? :updated
+              status
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/workflow/activerecord/job.rb

@@ -0,0 +1,73 @@
+require 'libis/workflow/base/job'
+require 'libis/workflow/activerecord/base'
+
+module Libis
+  module Workflow
+    module ActiveRecord
+
+      class Job < ::ActiveRecord::Base
+        include ::Libis::Workflow::Base::Job
+        include ::Libis::Workflow::ActiveRecord::Base
+
+        # noinspection RailsParamDefResolve
+        has_many :runs, -> {order 'created_at asc'},
+                 class_name: Libis::Workflow::ActiveRecord::Run.to_s,
+                 foreign_key: :job_id,
+                 autosave: true
+        # noinspection RailsParamDefResolve
+        belongs_to :workflow, class_name: Libis::Workflow::ActiveRecord::Workflow.to_s,
+                 autosave: true
+
+        # index({workflow_id: 1, workflow_type: 1, name: 1}, {name: 'by_workflow'})
+
+        def self.from_hash(hash)
+          self.create_from_hash(hash, [:name]) do |item, cfg|
+            item.workflow = Libis::Workflow::ActiveRecord::Workflow.from_hash(name: cfg.delete('workflow'))
+          end
+        end
+
+        def logger
+          # noinspection RubyResolve
+          return ::Libis::Workflow::ActiveRecord::Config.logger unless self.log_to_file
+          logger = ::Logging::Repository.instance[self.name]
+          return logger if logger
+          unless ::Logging::Appenders[self.name]
+            ::Logging::Appenders::RollingFile.new(
+                self.name,
+                filename: File.join(::Libis::Workflow::ActiveRecord::Config[:log_dir], "#{self.name}.{{%Y%m%d}}.log"),
+                layout: ::Libis::Workflow::ActiveRecord::Config.get_log_formatter,
+                truncate: true,
+                age: self.log_age,
+                keep: self.log_keep,
+                roll_by: 'date',
+                level: self.log_level
+            )
+          end
+          logger = ::Libis::Workflow::ActiveRecord::Config.logger(self.name, self.name)
+          logger.additive = false
+          logger
+        end
+
+        # noinspection RubyStringKeysInHashInspection
+        def execute(opts = {})
+          opts['run_config'] ||= {}
+          if self.log_each_run
+            opts['run_config']['log_to_file'] = true
+            opts['run_config']['log_level'] = self.log_level
+          end
+          if (run_name = opts.delete('run_name'))
+            opts['run_config']['run_name'] = run_name
+          end
+          super opts
+        end
+
+        # def create_run_object
+        #   # noinspection RubyResolve
+        #   self.runs.build
+        # end
+
+      end
+
+    end
+  end
+end

data/lib/libis/workflow/activerecord/run.rb

@@ -0,0 +1,99 @@
+require 'fileutils'
+require 'libis/workflow/base/run'
+
+module Libis
+  module Workflow
+    module ActiveRecord
+
+      class Run < Libis::Workflow::ActiveRecord::WorkItem
+
+        include ::Libis::Workflow::Base::Run
+
+        property_field :start_date, type: Time, default: lambda {Time.now}
+        property_field :log_to_file, type: TrueClass, default: false
+        property_field :log_level, default: 'INFO'
+        property_field :log_filename
+        property_field :run_name
+
+        # noinspection RailsParamDefResolve
+        belongs_to :job, class_name: Libis::Workflow::ActiveRecord::Job.to_s,
+                 autosave: true
+
+        set_callback(:destroy, :before) do |run|
+          run.rm_workdir
+          run.rm_log
+        end
+
+        def rm_log
+          # noinspection RubyResolve
+          log_file = self.log_filename
+          FileUtils.rm(log_file) if log_file && !log_file.blank? && File.exist?(log_file)
+        end
+
+        def rm_workdir
+          workdir = self.work_dir
+          FileUtils.rmtree workdir if workdir && !workdir.blank? && Dir.exist?(workdir)
+        end
+
+        def work_dir
+          # noinspection RubyResolve
+          dir = File.join(Libis::Workflow::Config.workdir, self.id.to_s)
+          FileUtils.mkpath dir unless Dir.exist?(dir)
+          dir
+        end
+
+        def run(action = :run)
+          self.start_date = Time.now
+          self.tasks = []
+          super action
+          close_logger
+        end
+
+        def logger
+          # noinspection RubyResolve
+          unless self.log_to_file
+            return self.job.logger
+          end
+          logger = ::Logging::Repository.instance[self.name]
+          return logger if logger
+          unless ::Logging::Appenders[self.name]
+            # noinspection RubyResolve
+            self.log_filename ||= File.join(::Libis::Workflow::ActiveRecord::Config[:log_dir], "#{self.name}-#{self.id}.log")
+            # noinspection RubyResolve
+            ::Logging::Appenders::File.new(
+                self.name,
+                filename: self.log_filename,
+                layout: ::Libis::Workflow::ActiveRecord::Config.get_log_formatter,
+                level: self.log_level
+            )
+          end
+          logger = ::Libis::Workflow::ActiveRecord::Config.logger(self.name, self.name)
+          logger.additive = false
+          # noinspection RubyResolve
+          logger.level = self.log_level
+          logger
+        end
+
+        def close_logger
+          # noinspection RubyResolve
+          return unless self.log_to_file
+          ::Logging::Appenders[self.name].close
+          ::Logging::Appenders.remove(self.name)
+          ::Logging::Repository.instance.delete(self.name)
+        end
+
+        def name
+          parts = [self.job.name]
+          parts << self.run_name unless self.run_name.blank?
+          parts << self.created_at.strftime('%Y%m%d-%H%M%S')
+          parts << self.id.to_s if self.run_name.blank?
+          parts.join('-')
+        rescue
+          self.id.to_s
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/workflow/activerecord/version.rb

@@ -0,0 +1,7 @@
+module Libis
+  module Workflow
+    module ActiveRecord
+      VERSION = '0.9.0' unless const_defined? :VERSION # the guard is against a redefinition warning that happens on Travis
+    end
+  end
+end

data/lib/libis/workflow/activerecord/work_item.rb

@@ -0,0 +1,90 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'libis-workflow-activerecord'
+
+require_relative 'helpers/hash_serializer'
+require_relative 'helpers/status_serializer'
+require_relative 'helpers/property_helper'
+
+module Libis
+  module Workflow
+    module ActiveRecord
+
+      class WorkItem < ::ActiveRecord::Base
+        include Libis::Workflow::Base::WorkItem
+        include Libis::Workflow::ActiveRecord::Base
+        include Libis::Workflow::ActiveRecord::Helpers::PropertyHelper
+
+        self.table_name = 'work_items'
+        # noinspection RubyArgCount
+        serialize :options, Libis::Workflow::ActiveRecord::Helpers::HashSerializer
+        # noinspection RubyArgCount
+        serialize :properties, Libis::Workflow::ActiveRecord::Helpers::HashSerializer
+        # noinspection RubyArgCount
+        serialize :status_log, Libis::Workflow::ActiveRecord::Helpers::StatusSerializer
+
+        # noinspection RailsParamDefResolve
+        has_many :items,
+                 -> {order('id')},
+                 class_name: Libis::Workflow::ActiveRecord::WorkItem.to_s,
+                 foreign_key: :parent_id,
+                 autosave: true
+
+        # noinspection RailsParamDefResolve
+        belongs_to :parent, class_name: Libis::Workflow::ActiveRecord::WorkItem.to_s,
+                   inverse_of: :items,
+                   autosave: true
+
+        def add_item(item)
+          raise Libis::WorkflowError, 'Trying to add item already linked to another item' unless item.parent.nil?
+          super(item)
+        end
+
+        def duplicate
+          new_item = self.class.new
+          new_item.properties = {}.with_indifferent_access
+          self.properties.each {|k, v| new_item.properties[k.to_sym] = v.dup}
+          new_item.options = {}.with_indifferent_access
+          self.options.each {|k, v| new_item.options[k.to_sym] = v.dup}
+          new_item.status_log = []
+          yield new_item if block_given?
+          new_item
+        end
+
+        def copy_item(item, &block)
+          new_item = item.duplicate &block
+          new_item.parent = nil
+          add_item new_item
+          item.items.each {|i| new_item.copy_item(i)}
+          new_item
+        end
+
+        def move_item(item)
+          old_parent = item.parent
+          item.parent = self
+          item.save
+          old_parent.items.reset
+          self.items.reset
+          item
+        end
+
+        def get_items
+          self.items
+        end
+
+        def get_item_list
+          self.items.to_a
+        end
+
+        protected
+
+        def add_status_log(info)
+          # noinspection RubyResolve
+          self.status_log << info.with_indifferent_access
+          self.status_log.last
+        end
+
+      end
+
+    end
+  end
+end