active_worker 0.50.0

data/lib/active_worker/behavior/create_from_error.rb

@@ -0,0 +1,21 @@
+module ActiveWorker
+  module Behavior
+    module CreateFromError
+
+      def self.extended(base)
+        base.field :stack_trace
+        base.field :error_type
+      end
+
+      def create_error_from_configuration(configuration, error)
+        constructor_options = {
+            :message => "#{configuration.event_name} FAILED: #{error.message}",
+            :stack_trace => error.backtrace.join("\n"),
+            :configuration => configuration,
+            :error_type => error.class.name
+        }
+        create! constructor_options
+      end
+    end
+  end
+end

data/lib/active_worker/behavior/execute_concurrently.rb

@@ -0,0 +1,142 @@
+module ActiveWorker
+
+  THREADED_MODE = :local_worker_thread
+  FORKING_MODE = :local_worker_fork
+  DEFAULT_MODE = FORKING_MODE
+
+  PARENT = :parent
+  FORKED = :forked
+
+  module Behavior
+    module ExecuteConcurrently
+
+      def local_worker_mode=(mode)
+        @@local_worker_mode = mode
+      end
+
+      def local_worker_mode
+        @@local_worker_mode ||= FORKING_MODE
+      end
+
+      def threaded?
+        local_worker_mode == THREADED_MODE
+      end
+
+      def forking?
+        local_worker_mode == FORKING_MODE
+      end
+
+      def role
+        @@role ||= PARENT
+      end
+
+      def role=(role)
+        @@role = role
+      end
+
+      def parent?
+        role == PARENT
+      end
+
+      def forked?
+        role == FORKED
+      end
+
+      def pids
+        @pids ||= []
+      end
+
+      def threads
+        @threads ||= []
+      end
+
+      def execute_concurrently(params)
+        new_threads = params.map do |param|
+          case local_worker_mode
+            when THREADED_MODE
+              execute_thread param
+            when FORKING_MODE
+              execute_fork param
+          end
+        end
+
+        threads.concat new_threads
+        new_threads
+      end
+
+      def wait_for_children
+        threads.each do |thread|
+          thread.join if thread
+        end
+
+        cleanup_after_children
+      end
+
+      def cleanup_after_children
+        @pids = []
+        @threads = []
+      end
+
+      def kill_children
+        pids.each do |pid|
+          begin
+            Process.kill("TERM", pid) if pid
+          rescue Errno::ESRCH
+            puts "PID: #{pid} did not exist when we went to kill it"
+          end
+        end
+      end
+
+      def execute_thread(param)
+        Thread.new do
+          in_thread(param)
+        end
+      end
+
+      def execute_fork(param)
+        pid = fork do
+          in_fork(param)
+        end
+        pids << pid
+        Process.detach(pid)
+      end
+
+      def in_thread(param)
+        execute(param)
+      end
+
+      def in_fork(param)
+        after_fork(param)
+        execute(param)
+      rescue SignalException
+        self.handle_termination([param.to_param])
+        exit
+      rescue Exception => e
+        self.handle_error(e, :in_fork, [param.to_param])
+      end
+
+      def after_fork(param)
+        self.role = FORKED
+        cleanup_after_children
+        set_process_name(param)
+        reset_mongoid
+        reset_resque
+      end
+
+      def set_process_name(param)
+        $0 = "ActiveWorker Forked from #{Process.ppid} for #{param}"
+      end
+
+      def reset_mongoid
+        Mongoid::Sessions.clear
+      end
+
+      def reset_resque
+        Resque.redis.client.reconnect
+        trap("TERM", "DEFAULT")
+      end
+
+    end
+  end
+
+end

data/lib/active_worker/behavior/has_modes.rb

@@ -0,0 +1,44 @@
+module ActiveWorker
+  module Behavior
+    module HasModes
+
+      class ModeNotSupportedException < StandardError
+      end
+
+      module ClassExtensions
+
+        def modes_map
+          @modes_map ||= ModesMap.new
+        end
+
+        def modes
+          modes_map.modes
+        end
+
+        def add_mode(*args)
+          modes_map.add_mode(*args)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassExtensions)
+        base.template_field :mode
+        base.before_save :set_mode_defined_fields
+      end
+
+      def set_mode_defined_fields
+        unless mode.nil? || mode.empty?
+          if self.class.modes_map.supports? mode
+            self.class.modes_map.mode(mode).each_pair do |field, value|
+              write_attribute(field, value) unless read_attribute(field)
+            end
+          else
+            raise ModeNotSupportedException, "Mode \"#{mode}\" not in Modes List: #{self.class.modes} for #{self.class}"
+          end
+        end
+      end
+
+    end
+  end
+
+end

data/lib/active_worker/behavior/has_root_object.rb

@@ -0,0 +1,50 @@
+module ActiveWorker
+  module Behavior
+    module HasRootObject
+
+      module ClassExtensions
+        def root_object_relation(relation)
+          belongs_to :root_object, :polymorphic => true, inverse_of: relation
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassExtensions)
+        base.before_save :set_root_object
+        base.index({:root_object_id => -1}, {:background => true})
+      end
+
+      def root_owner
+        nil
+      end
+
+      def notify_root_of_child_started
+        if root_object
+          root_object.child_started
+          root_object.save!
+        end
+      end
+
+      def notify_root_of_finished
+        if root_object
+          root_object.child_finished
+          root_object.save!
+        end
+      end
+
+      def get_root_object_id
+        return root_object_id if root_object_id
+        set_root_object
+        root_object_id
+      end
+
+      def set_root_object
+        return unless root_owner
+        self.root_object_id = root_owner.get_root_object_id
+        self.root_object_type = root_owner.root_object_type
+        true
+      end
+
+    end
+  end
+end

data/lib/active_worker/behavior/hashable.rb

@@ -0,0 +1,79 @@
+module ActiveWorker
+  module Behavior
+    module Hashable
+
+      def get_as_flat_hash_by_root_object(root_object)
+        configs = []
+        col = get_mongoid_collection
+        col.find("root_object_id" => root_object.id).each do |config|
+          canonicalize(config, col)
+          configs << config
+        end
+        configs
+      end
+
+      def get_as_hash_by_root_object(root_object)
+        configs = []
+        col = get_mongoid_collection
+        col.find("root_object_id" => root_object.id, "parent_configuration_id" => nil).each do |config|
+          config["configurations"] = get_children_for(col, config["_id"])
+          canonicalize(config, col)
+          configs << config
+        end
+        configs
+      end
+
+      def get_children_for(col, parent_configuration_id)
+        configs = []
+        col.find("parent_configuration_id" => parent_configuration_id).each do |config|
+          config["configurations"] = get_children_for(col, config["_id"])
+          canonicalize(config, col)
+          configs << config
+        end
+        configs
+      end
+
+
+
+      def get_renderable_hash_by_root_object(root_object)
+        configs = []
+        col = get_mongoid_collection
+        col.find("root_object_id" => root_object.id, "parent_configuration_id" => nil, "renderable" => true).each do |config|
+          config["configurations"] = get_renderable_children_for(col, config["_id"])
+          canonicalize(config, col)
+          configs << config
+        end
+        configs
+      end
+
+      def renderable_hash_for_configuration(configuration_id)
+        col = get_mongoid_collection
+        config = col.find("_id" => configuration_id).first
+        config["configurations"] = get_renderable_children_for(col, config["_id"])
+        canonicalize(config, col)
+        config
+      end
+
+      def get_renderable_children_for(col, parent_configuration_id)
+        configs = []
+        col.find("parent_configuration_id" => parent_configuration_id, "renderable" => true).each do |config|
+          config["configurations"] = get_renderable_children_for(col, config["_id"])
+          canonicalize(config, col)
+          configs << config
+        end
+        configs
+      end
+
+      def canonicalize(config, col)
+        config["_type"] ||= col.name.classify
+        config["_id"] = config["_id"].to_s
+      end
+
+
+      def get_mongoid_collection
+        Mongoid.default_session.collections.select {|c| c.name == self.collection_name.to_s }.first
+      end
+
+    end
+  end
+end

data/lib/active_worker/configuration.rb

@@ -0,0 +1,143 @@
+module ActiveWorker
+  class Configuration
+    include Mongoid::Document
+    include Behavior::HasRootObject
+    extend Behavior::Hashable
+    POLLING_INTERVAL = 0.1
+
+    has_many :events, :class_name => "ActiveWorker::Event"
+
+    has_many :configurations,
+             :as => :parent_configuration,
+             :class_name => 'ActiveWorker::Configuration',
+             :autosave => true
+
+    belongs_to :parent_configuration,
+               :polymorphic => true
+
+    alias_method :root_owner, :parent_configuration
+    root_object_relation :configurations
+
+    field :polling_interval, :type => Integer, :default => 1
+    field :renderable, :type => Boolean, :default => false
+    field :flags, type: Hash, default: {}
+
+    before_save :set_flags
+
+    scope :mine, ->(parent_config) { where(parent_configuration_id: parent_config.id) }
+
+    def launch
+      configurations = expand_for_workers
+      configurations.each(&:enqueue_job)
+      configurations += collect_after_launch_configurations(configurations)
+      configurations
+    end
+
+    def collect_after_launch_configurations(configurations)
+      self.class.after_launch_methods.map { |method| send(method, configurations) }.flatten
+    end
+
+    def expand_for_workers
+      [self]
+    end
+
+    def expand_for_threads
+      [self]
+    end
+
+    def configurations_for_events
+      [self]
+    end
+
+    def enqueue_job
+      self.class.controller_class.run_remotely.execute_expanded(self.id)
+      self
+    end
+
+    def supported_child_configurations
+      []
+    end
+
+    def defined_fields
+      attributes.select { |k, v| self.class.config_fields.include? k.to_sym }
+    end
+
+    def event_name
+      parts = self.class.name.split("::")
+      parts.pop
+      parts.join(" ")
+    end
+
+    def renderable_configurations
+      configurations.select { |c| c.renderable }
+    end
+
+    def completed?
+      FinishedEvent.where(configuration_id: id).count > 0
+    end
+
+    def wait_until_completed
+      sleep(POLLING_INTERVAL) until completed?
+    end
+
+    def started
+      StartedEvent.create(configuration: self)
+    end
+
+    def finished
+      FinishedEvent.create(configuration: self)
+    end
+
+    def notify
+      NotificationEvent.create(configuration: self)
+    end
+
+    def notified?
+      NotificationEvent.where(configuration_id: id).count > 0
+    end
+
+    def set_flags
+      self.flags = parent_configuration.flags if parent_configuration
+      true
+    end
+
+    def self.controller_class
+      "#{self.parent}::Controller".constantize
+    end
+
+    def self.display_name
+      name.split("::").join(" ")
+    end
+
+    def self.css_name
+      name.split("::").join("_")
+    end
+
+    def self.template_field(name, *args)
+      config_field(name, *args)
+      template_fields << name
+    end
+
+    def self.config_field(name, *args)
+      field name, *args
+      config_fields << name
+    end
+
+    def self.template_fields
+      @template_fields ||= []
+    end
+
+    def self.config_fields
+      @config_fields ||= []
+    end
+
+    def self.after_launch(method)
+      after_launch_methods << method
+    end
+
+    def self.after_launch_methods
+      @after_launch_methods ||= []
+    end
+
+  end
+end