procrastinator 0.6.1 → 1.0.0.pre.rc2

data/lib/procrastinator/environment.rb

@@ -1,148 +0,0 @@
-module Procrastinator
-   class Environment
-      attr_reader :persister, :queue_definitions, :queue_workers, :processes, :test_mode
-
-      DEFAULT_LOG_DIRECTORY = 'log/'
-
-      def initialize(test_mode: false)
-         @test_mode         = test_mode
-         @queue_definitions = {}
-         @queue_workers     = []
-         @processes         = []
-         @log_dir           = DEFAULT_LOG_DIRECTORY
-         @log_level         = Logger::INFO
-      end
-
-      def persister_factory(&block)
-         @persister_factory = block
-
-         build_persister
-      end
-
-      def define_queue(name, properties={})
-         raise ArgumentError.new('queue name cannot be nil') if name.nil?
-
-         @queue_definitions[name] = properties
-      end
-
-      def spawn_workers
-         if @test_mode
-            @queue_definitions.each do |name, props|
-               @queue_workers << QueueWorker.new(props.merge(name:      name,
-                                                             persister: @persister))
-            end
-         else
-            @queue_definitions.each do |name, props|
-               pid = fork do
-                  build_persister
-                  worker = QueueWorker.new(props.merge(name:      name,
-                                                       persister: @persister,
-                                                       log_dir:   @log_dir,
-                                                       log_level: @log_level))
-
-                  Process.setproctitle("#{@process_prefix ? "#{@process_prefix}-" : ''}#{worker.long_name}") # tODO: add an app name prefix
-
-                  monitor_parent(worker)
-
-                  worker.work
-               end
-
-               Process.detach(pid) unless pid.nil?
-               @processes << pid
-            end
-         end
-      end
-
-      def act(*queue_names)
-         unless @test_mode
-            raise RuntimeError.new('Procrastinator.act called outside Test Mode. Enable test mode by setting Procrastinator.test_mode = true before running setup')
-         end
-
-         if queue_names.empty?
-            @queue_workers.each do |worker|
-               worker.act
-            end
-         else
-            queue_names.each do |name|
-               @queue_workers.find { |worker| worker.name == name }.act
-            end
-         end
-      end
-
-      def delay(queue: nil, run_at: Time.now.to_i, expire_at: nil, task:)
-         raise ArgumentError.new('task may not be nil') if task.nil?
-         raise MalformedTaskError.new('the provided task does not support #run method') unless task.respond_to? :run
-
-         # We're checking these on init because it's one of those extremely rare cases where you'd want to know
-         # incredibly early, because of the sub-processing. It's a bit belt-and suspenders, but UX is important for
-         # devs, too.
-         [:success, :fail, :final_fail].each do |method_name|
-            if task.respond_to?(method_name) && task.method(method_name).arity <= 0
-               raise MalformedTaskError.new("the provided task must accept a parameter to its ##{method_name} method")
-            end
-         end
-
-         if queue.nil? && @queue_definitions.size > 1
-            raise ArgumentError.new("queue must be specified when more than one is registered. Defined queues are: #{queue_definitions.keys.map { |k| ':' + k.to_s }.join(', ')}")
-         else
-            queue ||= @queue_definitions.keys.first
-            raise ArgumentError.new(%Q{there is no "#{queue}" queue registered in this environment}) if @queue_definitions[queue].nil?
-         end
-
-         @persister.create_task(queue:          queue,
-                                run_at:         run_at.to_i,
-                                initial_run_at: run_at.to_i,
-                                expire_at:      expire_at.nil? ? nil : expire_at.to_i,
-                                task:           YAML.dump(task))
-      end
-
-      def enable_test_mode
-         @test_mode = true
-      end
-
-      def log_dir(path)
-         @log_dir = path
-      end
-
-      def log_level(lvl)
-         @log_level = lvl
-      end
-
-      def process_prefix(prefix)
-         @process_prefix = prefix
-      end
-
-      private
-      def monitor_parent(worker)
-         parent_pid = Process.ppid
-
-         heartbeat_thread = Thread.new(parent_pid) do |ppid|
-            loop do
-               begin
-                  Process.kill(0, ppid) # kill with 0 flag checks if the process exists & has permissions
-               rescue Errno::ESRCH
-                  worker.log_parent_exit(ppid: ppid, pid: Process.pid)
-                  exit
-               end
-
-               sleep(5)
-            end
-         end
-
-         heartbeat_thread.abort_on_exception = true
-      end
-
-      def build_persister
-         @persister = @persister_factory.call
-
-         raise ArgumentError.new('persister cannot be nil') if @persister.nil?
-
-         [:read_tasks, :create_task, :update_task, :delete_task].each do |method|
-            raise MalformedPersisterError.new("persister must repond to ##{method}") unless @persister.respond_to? method
-         end
-      end
-   end
-
-   class MalformedPersisterError < StandardError
-   end
-end

data/lib/procrastinator/task_worker.rb

@@ -1,120 +0,0 @@
-require 'yaml'
-
-module Procrastinator
-   class TaskWorker
-      attr_reader :id, :run_at, :initial_run_at, :expire_at, :task, :attempts, :last_fail_at, :last_error
-
-      def initialize(id: nil,
-                     run_at: nil,
-                     initial_run_at: nil,
-                     expire_at: nil,
-                     attempts: 0,
-                     timeout: nil,
-                     max_attempts: nil,
-                     last_fail_at: nil,
-                     last_error: nil,
-                     task:,
-                     logger: Logger.new(StringIO.new))
-         @id             = id
-         @run_at         = run_at.nil? ? nil : run_at.to_i
-         @initial_run_at = initial_run_at.to_i
-         @expire_at      = expire_at.nil? ? nil : expire_at.to_i
-         @task           = YAML.load(task)
-         @attempts       = attempts || 0
-         @max_attempts   = max_attempts
-         @timeout        = timeout
-         @last_fail_at   = last_fail_at
-         @last_error     = last_error
-         @logger         = logger
-
-         raise(MalformedTaskError.new('given task does not support #run method')) unless @task.respond_to? :run
-         raise(ArgumentError.new('timeout cannot be negative')) if timeout && timeout < 0
-      end
-
-      def work
-         @attempts += 1
-
-         begin
-            raise(TaskExpiredError.new("task is over its expiry time of #{@expire_at}")) if expired?
-
-            Timeout::timeout(@timeout) do
-               @task.run
-            end
-
-            try_hook(:success, @logger)
-
-            @logger.debug("Task completed: #{YAML.dump(@task)}")
-
-            @last_error   = nil
-            @last_fail_at = nil
-         rescue StandardError => e
-            @last_fail_at = Time.now.to_i
-
-            if too_many_fails? || expired?
-               try_hook(:final_fail, @logger, e)
-
-               @run_at     = nil
-               @last_error = "#{expired? ? 'Task expired' : 'Task failed too many times'}: #{e.backtrace.join("\n")}"
-
-               @logger.debug("Task failed permanently: #{YAML.dump(@task)}")
-            else
-               try_hook(:fail, @logger, e)
-
-               @last_error = %Q[Task failed: #{e.message}\n#{e.backtrace.join("\n")}]
-               @logger.debug("Task failed: #{YAML.dump(@task)}")
-
-               reschedule
-            end
-         end
-      end
-
-      def successful?
-         if !expired? && @attempts <= 0
-            raise(RuntimeError, 'you cannot check for success before running #work')
-         end
-
-         @last_error.nil? && @last_fail_at.nil?
-      end
-
-      def too_many_fails?
-         !@max_attempts.nil? && @attempts >= @max_attempts
-      end
-
-      def expired?
-         !@expire_at.nil? && Time.now.to_i > @expire_at
-      end
-
-      def to_hash
-         {id:             @id,
-          run_at:         @run_at,
-          initial_run_at: @initial_run_at,
-          expire_at:      @expire_at,
-          attempts:       @attempts,
-          last_fail_at:   @last_fail_at,
-          last_error:     @last_error,
-          task:           YAML.dump(@task)}
-      end
-
-      private
-      def try_hook(method, *params)
-         begin
-            @task.send(method, *params) if @task.respond_to? method
-         rescue StandardError => e
-            $stderr.puts "#{method.to_s.capitalize} hook error: #{e.message}"
-         end
-      end
-
-      def reschedule
-         # (30 + n_attempts^4) seconds is chosen to rapidly expand
-         # but with the baseline of 30s to avoid hitting the disc too frequently.
-
-         @run_at += 30 + (@attempts**4)
-      end
-   end
-
-   class TaskExpiredError < StandardError
-   end
-
-   class MalformedTaskError < StandardError
-   end
-end