cloudtasker 0.2.0 → 0.3.0

data/lib/cloudtasker/config.rb

@@ -1,15 +1,24 @@
 # frozen_string_literal: true
 
+require 'logger'
+
 module Cloudtasker
   # Holds cloudtasker configuration. See Cloudtasker#configure
   class Config
     attr_accessor :redis
     attr_writer :secret, :gcp_location_id, :gcp_project_id,
-                :gcp_queue_id, :processor_host, :processor_path
+                :gcp_queue_id, :processor_path, :logger, :mode, :max_retries
+
+    # Retry header in Cloud Task responses
+    RETRY_HEADER = 'X-CloudTasks-TaskExecutionCount'
 
+    # Default values
     DEFAULT_LOCATION_ID = 'us-east1'
     DEFAULT_PROCESSOR_PATH = '/cloudtasker/run'
 
+    # The number of times jobs will be attempted before declaring them dead
+    DEFAULT_MAX_RETRY_ATTEMPTS = 25
+
     PROCESSOR_HOST_MISSING = <<~DOC
       Missing host for processing.
       Please specify a processor hostname in form of `https://some-public-dns.example.com`'
@@ -27,6 +36,46 @@ module Cloudtasker
       Please specify a secret in the cloudtasker initializer or add Rails secret_key_base in your credentials
     DOC
 
+    #
+    # The number of times jobs will be retried. This number of
+    # retries does not include failures due to the application being unreachable.
+    #
+    #
+    # @return [Integer] The number of retries
+    #
+    def max_retries
+      @max_retries ||= DEFAULT_MAX_RETRY_ATTEMPTS
+    end
+
+    #
+    # The operating mode.
+    #   - :production => process tasks via GCP Cloud Task.
+    #   - :development => process tasks locally via Redis.
+    #
+    # @return [<Type>] <description>
+    #
+    def mode
+      @mode ||= environment == 'development' ? :development : :production
+    end
+
+    #
+    # Return the current environment.
+    #
+    # @return [String] The environment name.
+    #
+    def environment
+      ENV['CLOUDTASKER_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+    end
+
+    #
+    # Return the Cloudtasker logger.
+    #
+    # @return [Logger, any] The cloudtasker logger.
+    #
+    def logger
+      @logger ||= defined?(Rails) ? Rails.logger : ::Logger.new(STDOUT)
+    end
+
     #
     # Return the full URL of the processor. Worker payloads will be sent
     # to this URL.
@@ -37,6 +86,19 @@ module Cloudtasker
       File.join(processor_host, processor_path)
     end
 
+    #
+    # Set the processor host. In the context of Rails the host will
+    # also be added to the list of authorized Rails hosts.
+    #
+    # @param [String] val The processor host to set.
+    #
+    def processor_host=(val)
+      @processor_host = val
+
+      # Add processor host to the list of authorized hosts
+      Rails.application.config.hosts << val.gsub(%r{https?://}, '') if val && defined?(Rails)
+    end
+
     #
     # The hostname of the application processing the workers. The hostname must
     # be reachable from Cloud Task.
@@ -93,7 +155,7 @@ module Cloudtasker
     #
     def secret
       @secret || (
-        defined?(Rails) && Rails.application.credentials&.secret_key_base
+        defined?(Rails) && Rails.application.credentials&.dig(:secret_key_base)
       ) || raise(StandardError, SECRET_MISSING_ERROR)
     end
 

data/lib/cloudtasker/cron/job.rb

@@ -179,8 +179,8 @@ module Cloudtasker
         next_worker = worker.new_instance.tap { |e| e.job_meta.set(key(:time_at), next_time.iso8601) }
 
         # Schedule next worker
-        resp = next_worker.schedule(time_at: next_time)
-        cron_schedule.update(task_id: resp.name, job_id: next_worker.job_id)
+        task = next_worker.schedule(time_at: next_time)
+        cron_schedule.update(task_id: task.id, job_id: next_worker.job_id)
       end
 
       #

data/lib/cloudtasker/cron/schedule.rb

@@ -56,7 +56,7 @@ module Cloudtasker
       #
       def self.load_from_hash!(hash)
         schedules = hash.map do |id, config|
-          schedule_config = JSON.parse(config.to_json, symbolize_names: true).merge(id: id)
+          schedule_config = JSON.parse(config.to_json, symbolize_names: true).merge(id: id.to_s)
           create(schedule_config)
         end
 
@@ -99,7 +99,7 @@ module Cloudtasker
         return false unless schedule
 
         # Delete task and stored schedule
-        Task.delete(schedule.task_id) if schedule.task_id
+        CloudTask.delete(schedule.task_id) if schedule.task_id
         redis.del(schedule.gid)
       end
 
@@ -252,17 +252,27 @@ module Cloudtasker
       # then any existing cloud task is removed and a task is recreated.
       #
       def save(update_task: true)
-        return false unless valid? && changed?
+        return false unless valid?
 
         # Save schedule
         config_was_changed = config_changed?
         redis.write(gid, to_h)
 
         # Stop there if backend does not need update
-        return true unless update_task && config_was_changed
+        return true unless update_task && (config_was_changed || !task_id || !CloudTask.find(task_id))
 
+        # Update backend
+        persist_cloud_task
+      end
+
+      private
+
+      #
+      # Update the task in backend.
+      #
+      def persist_cloud_task
         # Delete previous instance
-        Task.delete(task_id) if task_id
+        CloudTask.delete(task_id) if task_id
 
         # Schedule worker
         worker_instance = Object.const_get(worker).new

data/lib/cloudtasker/dead_worker_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  class DeadWorkerError < StandardError
+  end
+end

data/lib/cloudtasker/local_server.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'cloudtasker/backend/redis_task'
+
+module Cloudtasker
+  # Process jobs stored in Redis.
+  # Only to be used in development.
+  class LocalServer
+    # Max number of task requests sent to the processing server
+    CONCURRENCY = (ENV['CLOUDTASKER_CONCURRENCY'] || 5).to_i
+
+    #
+    # Stop the local server.
+    #
+    def stop
+      @done = true
+
+      # Terminate threads and repush tasks
+      @threads&.each do |t|
+        t.terminate
+        t['task']&.retry_later(0, is_error: false)
+      end
+
+      # Wait for main server to be done
+      sleep 1 while @start&.alive?
+    end
+
+    #
+    # Start the local server
+    #
+    #
+    def start
+      @start ||= Thread.new do
+        until @done
+          process_jobs
+          sleep 1
+        end
+        Cloudtasker.logger.info('[Cloudtasker/Server] Local server exiting...')
+      end
+    end
+
+    #
+    # Process enqueued workers.
+    #
+    #
+    def process_jobs
+      @threads ||= []
+
+      # Remove any done thread
+      @threads.select!(&:alive?)
+
+      # Process tasks
+      while @threads.count < CONCURRENCY && (task = Cloudtasker::Backend::RedisTask.pop)
+        @threads << Thread.new do
+          Thread.current['task'] = task
+          Thread.current['attempts'] = 0
+
+          # Deliver task
+          begin
+            Thread.current['task'].deliver
+          rescue Errno::ECONNREFUSED => e
+            raise(e) unless Thread.current['attempts'] < 3
+
+            # Retry on connection error, in case the web server is not
+            # started yet.
+            Thread.current['attempts'] += 1
+            sleep(3)
+            retry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cloudtasker/railtie.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  # Rails extensions
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'tasks/setup_queue.rake'
+    end
+  end
+end

data/lib/cloudtasker/testing.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'cloudtasker/backend/memory_task'
+
+module Cloudtasker
+  # Enable/Disable test mode for Cloudtasker
+  module Testing
+    module_function
+
+    #
+    # Set the test mode, either permanently or
+    # temporarily (via block).
+    #
+    # @param [Symbol] mode The test mode.
+    #
+    # @return [Symbol] The test mode.
+    #
+    def switch_test_mode(mode)
+      if block_given?
+        current_mode = @test_mode
+        begin
+          @test_mode = mode
+          yield
+        ensure
+          @test_mode = current_mode
+        end
+      else
+        @test_mode = mode
+      end
+    end
+
+    #
+    # Set cloudtasker to real mode temporarily
+    #
+    # @param [Proc] &block The block to run in real mode
+    #
+    def enable!(&block)
+      switch_test_mode(:enabled, &block)
+    end
+
+    #
+    # Set cloudtasker to fake mode temporarily
+    #
+    # @param [Proc] &block The block to run in fake mode
+    #
+    def fake!(&block)
+      switch_test_mode(:fake, &block)
+    end
+
+    #
+    # Set cloudtasker to inline mode temporarily
+    #
+    # @param [Proc] &block The block to run in inline mode
+    #
+    def inline!(&block)
+      switch_test_mode(:inline, &block)
+    end
+
+    #
+    # Return true if Cloudtasker is enabled.
+    #
+    def enabled?
+      !@test_mode || @test_mode == :enabled
+    end
+
+    #
+    # Return true if Cloudtasker is in fake mode.
+    #
+    # @return [Boolean] True if jobs must be processed through drain calls.
+    #
+    def fake?
+      @test_mode == :fake
+    end
+
+    #
+    # Return true if Cloudtasker is in inline mode.
+    #
+    # @return [Boolean] True if jobs are run inline.
+    #
+    def inline?
+      @test_mode == :inline
+    end
+
+    #
+    # Return true if tasks should be managed in memory.
+    #
+    # @return [Boolean] True if jobs are managed in memory.
+    #
+    def in_memory?
+      !enabled?
+    end
+  end
+
+  # Add extra methods for testing purpose
+  module Worker
+    #
+    # Clear all jobs.
+    #
+    def self.clear_all
+      Backend::MemoryTask.clear
+    end
+
+    #
+    # Run all the jobs.
+    #
+    # @return [Array<any>] The return values of the workers perform method.
+    #
+    def self.drain_all
+      Backend::MemoryTask.drain
+    end
+
+    # Module class methods
+    module ClassMethods
+      #
+      # Return all jobs related to this worker class.
+      #
+      # @return [Array<Cloudtasker::Worker] The list of workers
+      #
+      def jobs
+        Backend::MemoryTask.jobs(to_s)
+      end
+
+      #
+      # Run all jobs related to this worker class.
+      #
+      # @return [Array<any>] The return values of the workers perform method.
+      #
+      def drain
+        Backend::MemoryTask.drain(to_s)
+      end
+    end
+  end
+end

data/lib/cloudtasker/unique_job/job.rb

@@ -40,7 +40,7 @@ module Cloudtasker
         @lock_instance ||=
           begin
             # Infer lock class and get instance
-            lock_name = options[:lock] || options['lock']
+            lock_name = options[:lock]
             lock_klass = Lock.const_get(lock_name.to_s.split('_').collect(&:capitalize).join)
             lock_klass.new(self)
           rescue NameError

data/lib/cloudtasker/unique_job/lock/base_lock.rb

@@ -43,7 +43,7 @@ module Cloudtasker
           @conflict_instance ||=
             begin
               # Infer lock class and get instance
-              strategy_name = options[:on_conflict] || options['on_conflict']
+              strategy_name = options[:on_conflict]
               strategy_klass = ConflictStrategy.const_get(strategy_name.to_s.split('_').collect(&:capitalize).join)
               strategy_klass.new(job)
             rescue NameError

data/lib/cloudtasker/unique_job/lock/until_executed.rb

@@ -24,9 +24,11 @@ module Cloudtasker
         def execute
           job.lock!
           yield
-          job.unlock!
         rescue LockError
           conflict_instance.on_execute { yield }
+        ensure
+          # Unlock the job on any error to avoid deadlocks.
+          job.unlock!
         end
       end
     end

data/lib/cloudtasker/unique_job/lock/while_executing.rb

@@ -13,9 +13,11 @@ module Cloudtasker
         def execute
           job.lock!
           yield
-          job.unlock!
         rescue LockError
           conflict_instance.on_execute { yield }
+        ensure
+          # Unlock the job on any error to avoid deadlocks.
+          job.unlock!
         end
       end
     end

data/lib/cloudtasker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cloudtasker
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/cloudtasker/worker.rb

@@ -6,7 +6,7 @@ module Cloudtasker
     # Add class method to including class
     def self.included(base)
       base.extend(ClassMethods)
-      base.attr_accessor :job_args, :job_id, :job_meta, :job_reenqueued
+      base.attr_accessor :job_args, :job_id, :job_meta, :job_reenqueued, :job_retries
     end
 
     #
@@ -44,7 +44,7 @@ module Cloudtasker
       return nil unless worker_klass.include?(self)
 
       # Return instantiated worker
-      worker_klass.new(payload.slice(:job_args, :job_id, :job_meta))
+      worker_klass.new(payload.slice(:job_args, :job_id, :job_meta, :job_retries))
     rescue NameError
       nil
     end
@@ -54,12 +54,12 @@ module Cloudtasker
       #
       # Set the worker runtime options.
       #
-      # @param [Hash] opts The worker options
+      # @param [Hash] opts The worker options.
       #
-      # @return [<Type>] <description>
+      # @return [Hash] The options set.
       #
       def cloudtasker_options(opts = {})
-        opt_list = opts&.map { |k, v| [k.to_s, v] } || [] # stringify
+        opt_list = opts&.map { |k, v| [k.to_sym, v] } || [] # symbolize
         @cloudtasker_options_hash = Hash[opt_list]
       end
 
@@ -69,7 +69,7 @@ module Cloudtasker
       # @return [Hash] The worker runtime options.
       #
       def cloudtasker_options_hash
-        @cloudtasker_options_hash
+        @cloudtasker_options_hash || {}
       end
 
       #
@@ -77,7 +77,7 @@ module Cloudtasker
       #
       # @param [Array<any>] *args List of worker arguments
       #
-      # @return [Google::Cloud::Tasks::V2beta3::Task] The Google Task response
+      # @return [Cloudtasker::CloudTask] The Google Task response
       #
       def perform_async(*args)
         perform_in(nil, *args)
@@ -89,7 +89,7 @@ module Cloudtasker
       # @param [Integer, nil] interval The delay in seconds.
       # @param [Array<any>] *args List of worker arguments.
       #
-      # @return [Google::Cloud::Tasks::V2beta3::Task] The Google Task response
+      # @return [Cloudtasker::CloudTask] The Google Task response
       #
       def perform_in(interval, *args)
         new(job_args: args).schedule(interval: interval)
@@ -101,11 +101,20 @@ module Cloudtasker
       # @param [Time, Integer] time_at The time at which the job should run.
       # @param [Array<any>] *args List of worker arguments
       #
-      # @return [Google::Cloud::Tasks::V2beta3::Task] The Google Task response
+      # @return [Cloudtasker::CloudTask] The Google Task response
       #
       def perform_at(time_at, *args)
         new(job_args: args).schedule(time_at: time_at)
       end
+
+      #
+      # Return the numbeer of times this worker will be retried.
+      #
+      # @return [Integer] The number of retries.
+      #
+      def max_retries
+        cloudtasker_options_hash[:max_retries] || Cloudtasker.config.max_retries
+      end
     end
 
     #
@@ -114,10 +123,20 @@ module Cloudtasker
     # @param [Array<any>] job_args The list of perform args.
     # @param [String] job_id A unique ID identifying this job.
     #
-    def initialize(job_args: [], job_id: nil, job_meta: {})
+    def initialize(job_args: [], job_id: nil, job_meta: {}, job_retries: 0)
       @job_args = job_args
       @job_id = job_id || SecureRandom.uuid
       @job_meta = MetaStore.new(job_meta)
+      @job_retries = job_retries || 0
+    end
+
+    #
+    # Return the Cloudtasker logger instance.
+    #
+    # @return [Logger, any] The cloudtasker logger.
+    #
+    def logger
+      @logger ||= WorkerLogger.new(self)
     end
 
     #
@@ -126,9 +145,22 @@ module Cloudtasker
     # @return [Any] The result of the perform.
     #
     def execute
-      Cloudtasker.config.server_middleware.invoke(self) do
-        perform(*job_args)
+      logger.info('Starting job...')
+      resp = Cloudtasker.config.server_middleware.invoke(self) do
+        begin
+          perform(*job_args)
+        rescue StandardError => e
+          try(:on_error, e)
+          return raise(e) unless job_dead?
+
+          # Flag job as dead
+          logger.info('Job dead')
+          try(:on_dead, e)
+          raise(DeadWorkerError, e)
+        end
       end
+      logger.info('Job done')
+      resp
     end
 
     #
@@ -138,11 +170,11 @@ module Cloudtasker
     #
     # @param [Time, Integer] interval The time at which the job should run
     #
-    # @return [Google::Cloud::Tasks::V2beta3::Task] The Google Task response
+    # @return [Cloudtasker::CloudTask] The Google Task response
     #
     def schedule(interval: nil, time_at: nil)
       Cloudtasker.config.client_middleware.invoke(self) do
-        Task.new(self).schedule(interval: interval, time_at: time_at)
+        WorkerHandler.new(self).schedule(interval: interval, time_at: time_at)
       end
     end
 
@@ -155,7 +187,7 @@ module Cloudtasker
     #
     # @param [Integer] interval Delay to wait before processing the job again (in seconds).
     #
-    # @return [Google::Cloud::Tasks::V2beta3::Task] The Google Task response
+    # @return [Cloudtasker::CloudTask] The Google Task response
     #
     def reenqueue(interval)
       @job_reenqueued = true
@@ -182,7 +214,8 @@ module Cloudtasker
         worker: self.class.to_s,
         job_id: job_id,
         job_args: job_args,
-        job_meta: job_meta.to_h
+        job_meta: job_meta.to_h,
+        job_retries: job_retries
       }
     end
 
@@ -207,5 +240,15 @@ module Cloudtasker
     def ==(other)
       other.is_a?(self.class) && other.job_id == job_id
     end
+
+    #
+    # Return true if the job has excceeded its maximum number
+    # of retries
+    #
+    # @return [Boolean] True if the job is dead
+    #
+    def job_dead?
+      job_retries >= Cloudtasker.config.max_retries
+    end
   end
 end