cloudtasker 0.1.0

data/lib/cloudtasker/task.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'google/cloud/tasks'
+
+module Cloudtasker
+  # Build, serialize and schedule tasks on GCP Cloud Task
+  class Task
+    attr_reader :worker, :job_args
+
+    # Alrogith used to sign the verification token
+    JWT_ALG = 'HS256'
+
+    # TODO: Move to a dedicated CloudTask class
+    #
+    # Find a Cloud task
+    #
+    # @param [String] id The ID of the task.
+    #
+    # @return [Google::Cloud::Tasks::V2beta3::Task] The cloud task.
+    #
+    def self.find(id)
+      client.get_task(id)
+    rescue Google::Gax::RetryError
+      nil
+    end
+
+    # TODO: Move to a dedicated CloudTask class
+    #
+    # Delete a Cloud task
+    #
+    # @param [String] id The ID of the task.
+    #
+    def self.delete(id)
+      client.delete_task(id)
+    rescue Google::Gax::RetryError
+      nil
+    end
+
+    #
+    # Execute a task worker from a task payload
+    #
+    # @param [Hash] payload The Cloud Task payload.
+    #
+    # @return [Any] The return value of the worker perform method.
+    #
+    def self.execute_from_payload!(payload)
+      worker = Cloudtasker::Worker.from_hash(payload) || raise(InvalidWorkerError)
+      worker.execute
+    end
+
+    #
+    # Return the Google Cloud Task client.
+    #
+    # @return [Google::Cloud::Tasks] The Google Cloud Task client.
+    #
+    def self.client
+      @client ||= ::Google::Cloud::Tasks.new(version: :v2beta3)
+    end
+
+    #
+    # Prepare a new cloud task.
+    #
+    # @param [Cloudtasker::Worker] worker The worker instance.
+    #
+    def initialize(worker)
+      @worker = worker
+    end
+
+    #
+    # Return the Google Cloud Task client.
+    #
+    # @return [Google::Cloud::Tasks] The Google Cloud Task client.
+    #
+    def client
+      self.class.client
+    end
+
+    #
+    # Return the cloudtasker configuration. See Cloudtasker#configure.
+    #
+    # @return [Cloudtasker::Config] The library configuration.
+    #
+    def config
+      Cloudtasker.config
+    end
+
+    #
+    # Return the fully qualified path for the Cloud Task queue.
+    #
+    # @return [String] The queue path.
+    #
+    def queue_path
+      client.queue_path(
+        config.gcp_project_id,
+        config.gcp_location_id,
+        config.gcp_queue_id
+      )
+    end
+
+    #
+    # Return the full task configuration sent to Cloud Task
+    #
+    # @return [Hash] The task body
+    #
+    def task_payload
+      {
+        http_request: {
+          http_method: 'POST',
+          url: config.processor_url,
+          headers: {
+            'Content-Type' => 'application/json',
+            'Authorization' => "Bearer #{Authenticator.verification_token}"
+          },
+          body: worker_payload.to_json
+        }
+      }
+    end
+
+    #
+    # Return the task payload that Google Task will eventually
+    # send to the job processor.
+    #
+    # The payload includes the worker name and the arguments to
+    # pass to the worker.
+    #
+    # The worker arguments should use primitive types as much
+    # as possible as all arguments will be serialized to JSON.
+    #
+    # @return [Hash] The job payload
+    #
+    def worker_payload
+      @worker_payload ||= {
+        worker: worker.class.to_s,
+        job_id: worker.job_id,
+        job_args: worker.job_args,
+        job_meta: worker.job_meta
+      }
+    end
+
+    #
+    # Return a protobuf timestamp specifying how to wait
+    # before running a task.
+    #
+    # @param [Integer, nil] interval The time to wait.
+    #
+    # @return [Google::Protobuf::Timestamp, nil] The protobuff timestamp
+    #
+    def schedule_time(interval: nil, time_at: nil)
+      return nil unless interval || time_at
+
+      # Generate protobuf timestamp
+      timestamp = Google::Protobuf::Timestamp.new
+      timestamp.seconds = (time_at || Time.now).to_i + interval.to_i
+      timestamp
+    end
+
+    #
+    # Schedule the task on GCP Cloud Task.
+    #
+    # @param [Integer, nil] interval How to wait before running the task.
+    #   Leave to `nil` to run now.
+    #
+    # @return [Google::Cloud::Tasks::V2beta3::Task] The Google Task response
+    #
+    def schedule(interval: nil, time_at: nil)
+      # Generate task payload
+      task = task_payload.merge(
+        schedule_time: schedule_time(interval: interval, time_at: time_at)
+      ).compact
+
+      # Create and return remote task
+      client.create_task(queue_path, task)
+    end
+  end
+end

data/lib/cloudtasker/unique_job.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'unique_job/middleware'
+
+Cloudtasker::UniqueJob::Middleware.configure

data/lib/cloudtasker/unique_job/config.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  module UniqueJob
+    # Manage UniqueJob configuration
+    class Config
+      KEY_NAMESPACE = 'cloudtasker-unique_job'
+    end
+  end
+end

data/lib/cloudtasker/unique_job/conflict_strategy/base_strategy.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  module UniqueJob
+    module ConflictStrategy
+      # Base behaviour for conflict strategies
+      class BaseStrategy
+        attr_reader :job
+
+        #
+        # Build a new instance of the class.
+        #
+        # @param [Cloudtasker::UniqueJob::Job] job The UniqueJob job
+        #
+        def initialize(job)
+          @job = job
+        end
+
+        #
+        # Handling logic to perform when a conflict occurs while
+        # scheduling a job.
+        #
+        def on_schedule
+          true
+        end
+
+        #
+        # Handling logic to perform when a conflict occurs while
+        # executing a job.
+        #
+        def on_execute
+          true
+        end
+      end
+    end
+  end
+end

data/lib/cloudtasker/unique_job/conflict_strategy/raise.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  module UniqueJob
+    module ConflictStrategy
+      # This strategy raises an error on conflict, both on client and server side.
+      class Raise < BaseStrategy
+        RESCHEDULE_DELAY = 5 # seconds
+
+        # Raise a Cloudtasker::UniqueJob::LockError
+        def on_schedule
+          raise_lock_error
+        end
+
+        # Raise a Cloudtasker::UniqueJob::LockError
+        def on_execute
+          raise_lock_error
+        end
+
+        private
+
+        def raise_lock_error
+          raise(UniqueJob::LockError, id: job.id, unique_id: job.unique_id)
+        end
+      end
+    end
+  end
+end

data/lib/cloudtasker/unique_job/conflict_strategy/reject.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  module UniqueJob
+    module ConflictStrategy
+      # This strategy rejects the job on conflict. This is equivalent to "do nothing".
+      class Reject < BaseStrategy
+      end
+    end
+  end
+end

data/lib/cloudtasker/unique_job/conflict_strategy/reschedule.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  module UniqueJob
+    module ConflictStrategy
+      # This strategy reschedules the job on conflict. This strategy can only
+      # be used with processing locks (e.g. while_executing).
+      class Reschedule < BaseStrategy
+        RESCHEDULE_DELAY = 5 # seconds
+
+        #
+        # A conflict on schedule means that this strategy is being used
+        # with a lock scheduling strategy (e.g. until_executed) instead of a
+        # processing strategy (e.g. while_executing). In this case we let the
+        # scheduling happen as it does not make sense to reschedule in this context.
+        #
+        def on_schedule
+          yield
+        end
+
+        #
+        # Reschedule the job.
+        #
+        def on_execute
+          job.worker.reenqueue(RESCHEDULE_DELAY)
+        end
+      end
+    end
+  end
+end

data/lib/cloudtasker/unique_job/job.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  module UniqueJob
+    # Wrapper class for Cloudtasker::Worker delegating to lock
+    # and conflict strategies
+    class Job
+      attr_reader :worker
+
+      # The default lock strategy to use. Defaults to "no lock".
+      DEFAULT_LOCK = UniqueJob::Lock::NoOp
+
+      #
+      # Build a new instance of the class.
+      #
+      # @param [Cloudtasker::Worker] worker The worker at hand
+      #
+      def initialize(worker)
+        @worker = worker
+      end
+
+      #
+      # Return the worker configuration options.
+      #
+      # @return [Hash] The worker configuration options.
+      #
+      def options
+        worker.class.cloudtasker_options_hash
+      end
+
+      #
+      # Return the instantiated lock.
+      #
+      # @return [Any] The instantiated lock
+      #
+      def lock_instance
+        @lock_instance ||=
+          begin
+            # Infer lock class and get instance
+            lock_name = options[:lock] || options['lock']
+            lock_klass = Lock.const_get(lock_name.to_s.split('_').collect(&:capitalize).join)
+            lock_klass.new(self)
+          rescue NameError
+            DEFAULT_LOCK.new(self)
+          end
+      end
+
+      #
+      # Return the list of arguments used for job uniqueness.
+      #
+      # @return [Array<any>] The list of unique arguments
+      #
+      def unique_args
+        worker.try(:unique_args, worker.job_args) || worker.job_args
+      end
+
+      #
+      # Return a unique description of the job in hash format.
+      #
+      # @return [Hash] Representation of the unique job in hash format.
+      #
+      def digest_hash
+        @digest_hash ||= {
+          class: worker.class.to_s,
+          unique_args: unique_args
+        }
+      end
+
+      #
+      # Return the worker job ID.
+      #
+      # @return [String] The worker job ID.
+      #
+      def id
+        worker.job_id
+      end
+
+      #
+      # Return the ID of the unique job.
+      #
+      # @return [String] The ID of the job.
+      #
+      def unique_id
+        Digest::SHA256.hexdigest(digest_hash.to_json)
+      end
+
+      #
+      # Return the Global ID of the unique job. The gid
+      # includes the UniqueJob namespace.
+      #
+      # @return [String] The global ID of the job
+      #
+      def unique_gid
+        [Config::KEY_NAMESPACE, unique_id].join('/')
+      end
+
+      #
+      # Return the Cloudtasker redis client.
+      #
+      # @return [Class] The Cloudtasker::RedisClient wrapper.
+      #
+      def redis
+        Cloudtasker::RedisClient
+      end
+
+      #
+      # Acquire a new unique job lock or check that the lock is
+      # currently allocated to this job.
+      #
+      # Raise a `Cloudtasker::UniqueJob::LockError` if the lock
+      # if taken by another job.
+      #
+      def lock!
+        redis.with_lock(unique_gid) do
+          locked_id = redis.get(unique_gid)
+
+          # Abort job lock process if lock is already taken by another job
+          raise(LockError, locked_id) if locked_id && locked_id != id
+
+          # Take job lock if the lock is currently free
+          redis.set(unique_gid, id) unless locked_id
+        end
+      end
+
+      #
+      # Delete the job lock.
+      #
+      def unlock!
+        redis.with_lock(unique_gid) do
+          locked_id = redis.get(unique_gid)
+          redis.del(unique_gid) if locked_id == id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  module UniqueJob
+    module Lock
+      # Base behaviour for locks
+      class BaseLock
+        attr_reader :job
+
+        #
+        # Build a new instance of the class.
+        #
+        # @param [Cloudtasker::UniqueJob::Job] job The UniqueJob job
+        #
+        def initialize(job)
+          @job = job
+        end
+
+        #
+        # Return the worker configuration options.
+        #
+        # @return [Hash] The worker configuration options.
+        #
+        def options
+          job.options
+        end
+
+        #
+        # Return the strategy to use by default. Can be overriden in each lock.
+        #
+        # @return [Cloudtasker::UniqueJob::ConflictStrategy::BaseStrategy] The strategy to use by default.
+        #
+        def default_conflict_strategy
+          ConflictStrategy::Reject
+        end
+
+        #
+        # Return the conflict strategy to use on conflict
+        #
+        # @return [Cloudtasker::UniqueJob::ConflictStrategy::BaseStrategy] The instantiated strategy.
+        #
+        def conflict_instance
+          @conflict_instance ||=
+            begin
+              # Infer lock class and get instance
+              strategy_name = options[:on_conflict] || options['on_conflict']
+              strategy_klass = ConflictStrategy.const_get(strategy_name.to_s.split('_').collect(&:capitalize).join)
+              strategy_klass.new(job)
+            rescue NameError
+              default_conflict_strategy.new(job)
+            end
+        end
+
+        #
+        # Lock logic invoked when a job is scheduled (client middleware).
+        #
+        def schedule
+          yield
+        end
+
+        #
+        # Lock logic invoked when a job is executed (server middleware).
+        #
+        def execute
+          yield
+        end
+      end
+    end
+  end
+end