cloudtasker 0.1.0

data/lib/cloudtasker/engine.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  # Cloudtasker Rails engine
+  class Engine < ::Rails::Engine
+    isolate_namespace Cloudtasker
+
+    initializer 'cloudtasker', before: :load_config_initializers do
+      Rails.application.routes.append do
+        mount Cloudtasker::Engine, at: '/cloudtasker'
+      end
+    end
+
+    config.generators do |g|
+      g.test_framework :rspec, fixture: false
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/cloudtasker/invalid_worker_error.rb

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

data/lib/cloudtasker/meta_store.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  # Manage meta information on workers. This meta stored is intended
+  # to be used by middlewares needing to store extra information on the
+  # job.
+  # The objective of this class is to provide a shared store to middleware
+  # while controlling access to its keys by preveenting access the hash directly
+  # (e.g. avoid wild merge or replace operations).
+  class MetaStore
+    #
+    # Build a new instance of the class.
+    #
+    # @param [<Type>] hash The worker meta hash
+    #
+    def initialize(hash = {})
+      @meta = JSON.parse((hash || {}).to_json, symbolize_names: true)
+    end
+
+    #
+    # Retrieve meta entry.
+    #
+    # @param [String, Symbol] key The key of the meta entry.
+    #
+    # @return [Any] The value of the meta entry.
+    #
+    def get(key)
+      @meta[key.to_sym] if key
+    end
+
+    #
+    # Set meta entry
+    #
+    # @param [String, Symbol] key The key of the meta entry.
+    # @param [Any] val The value of the meta entry.
+    #
+    # @return [Any] The value set
+    #
+    def set(key, val)
+      @meta[key.to_sym] = val if key
+    end
+
+    #
+    # Remove a meta information.
+    #
+    # @param [String, Symbol] key The key of the entry to delete.
+    #
+    # @return [Any] The value of the deleted key
+    #
+    def del(key)
+      @meta.delete(key.to_sym) if key
+    end
+
+    #
+    # Return the meta store as Hash.
+    #
+    # @return [Hash] The meta store as Hash.
+    #
+    def to_h
+      # Deep dup
+      JSON.parse(@meta.to_json, symbolize_names: true)
+    end
+
+    #
+    # Return the meta store as json.
+    #
+    # @param [Array<any>] *arg The to_json args.
+    #
+    # @return [String] The meta store as json.
+    #
+    def to_json(*arg)
+      @meta.to_json(*arg)
+    end
+
+    #
+    # Equality operator.
+    #
+    # @param [Any] other The object being compared.
+    #
+    # @return [Boolean] True if the object is equal.
+    #
+    def ==(other)
+      to_json == other.try(:to_json)
+    end
+  end
+end

data/lib/cloudtasker/middleware/chain.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Cloudtasker
+  module Middleware
+    # The class below was originally taken from Sidekiq.
+    # See: https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/middleware/chain.rb
+    #
+    # Middleware are callables configured to run before/after a message is processed.
+    # Middlewares can be configured to run on the client side (when jobs are pushed
+    # to Cloud Tasks) as well as on the server side (when jobs are processed by
+    # your application)
+    #
+    # To add middleware for the client:
+    #
+    # Cloudtasker.configure do |config|
+    #   config.client_middleware do |chain|
+    #     chain.add MyClientHook
+    #   end
+    # end
+    #
+    # To modify middleware for the server, just call
+    # with another block:
+    #
+    # Cloudtasker.configure do |config|
+    #   config.server_middleware do |chain|
+    #     chain.add MyServerHook
+    #     chain.remove ActiveRecord
+    #   end
+    # end
+    #
+    # To insert immediately preceding another entry:
+    #
+    # Cloudtasker.configure do |config|
+    #   config.client_middleware do |chain|
+    #     chain.insert_before ActiveRecord, MyClientHook
+    #   end
+    # end
+    #
+    # To insert immediately after another entry:
+    #
+    # Cloudtasker.configure do |config|
+    #   config.client_middleware do |chain|
+    #     chain.insert_after ActiveRecord, MyClientHook
+    #   end
+    # end
+    #
+    # This is an example of a minimal server middleware:
+    #
+    # class MyServerHook
+    #   def call(worker_instance, msg, queue)
+    #     puts "Before work"
+    #     yield
+    #     puts "After work"
+    #   end
+    # end
+    #
+    # This is an example of a minimal client middleware, note
+    # the method must return the result or the job will not push
+    # to Redis:
+    #
+    # class MyClientHook
+    #   def call(worker_class, msg, queue, redis_pool)
+    #     puts "Before push"
+    #     result = yield
+    #     puts "After push"
+    #     result
+    #   end
+    # end
+    #
+    class Chain
+      include Enumerable
+
+      #
+      # Build a new middleware chain.
+      #
+      def initialize
+        @entries = nil
+        yield self if block_given?
+      end
+
+      #
+      # Iterate over the list middlewares and execute the block on each item.
+      #
+      # @param [Proc] &block The block to execute on each item.
+      #
+      def each(&block)
+        entries.each(&block)
+      end
+
+      #
+      # Return the list of middlewares.
+      #
+      # @return [Array<Cloudtasker::Middleware::Chain::Entry>] The list of middlewares
+      #
+      def entries
+        @entries ||= []
+      end
+
+      #
+      # Remove a middleware from the list.
+      #
+      # @param [Class] klass The middleware class to remove.
+      #
+      def remove(klass)
+        entries.delete_if { |entry| entry.klass == klass }
+      end
+
+      #
+      # Add a middleware at the end of the list.
+      #
+      # @param [Class] klass The middleware class to add.
+      # @param [Arry<any>] *args The list of arguments to the middleware.
+      #
+      # @return [Array<Cloudtasker::Middleware::Chain::Entry>] The updated list of middlewares
+      #
+      def add(klass, *args)
+        remove(klass) if exists?(klass)
+        entries << Entry.new(klass, *args)
+      end
+
+      #
+      # Add a middleware at the beginning of the list.
+      #
+      # @param [Class] klass The middleware class to add.
+      # @param [Arry<any>] *args The list of arguments to the middleware.
+      #
+      # @return [Array<Cloudtasker::Middleware::Chain::Entry>] The updated list of middlewares
+      #
+      def prepend(klass, *args)
+        remove(klass) if exists?(klass)
+        entries.insert(0, Entry.new(klass, *args))
+      end
+
+      #
+      # Add a middleware before another middleware.
+      #
+      # @param [Class] oldklass The middleware class before which the new middleware should be inserted.
+      # @param [Class] newklass The middleware class to insert.
+      # @param [Arry<any>] *args The list of arguments for the inserted middleware.
+      #
+      # @return [Array<Cloudtasker::Middleware::Chain::Entry>] The updated list of middlewares
+      #
+      def insert_before(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || 0
+        entries.insert(i, new_entry)
+      end
+
+      #
+      # Add a middleware after another middleware.
+      #
+      # @param [Class] oldklass The middleware class after which the new middleware should be inserted.
+      # @param [Class] newklass The middleware class to insert.
+      # @param [Arry<any>] *args The list of arguments for the inserted middleware.
+      #
+      # @return [Array<Cloudtasker::Middleware::Chain::Entry>] The updated list of middlewares
+      #
+      def insert_after(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
+        entries.insert(i + 1, new_entry)
+      end
+
+      #
+      # Checks if middleware has been added to the list.
+      #
+      # @param [Class] klass The middleware class to check.
+      #
+      # @return [Boolean] Return true if the middleware is in the list.
+      #
+      def exists?(klass)
+        any? { |entry| entry.klass == klass }
+      end
+
+      #
+      # Checks if the middlware list is empty
+      #
+      # @return [Boolean] Return true if the middleware list is empty.
+      #
+      def empty?
+        @entries.nil? || @entries.empty?
+      end
+
+      #
+      # Return a list of instantiated middlewares. Each middleware gets
+      # initialize with the args originally passed to `add`, `insert_before` etc.
+      #
+      # @return [Array<any>] The list of instantiated middlewares.
+      #
+      def retrieve
+        map(&:make_new)
+      end
+
+      #
+      # Empty the list of middlewares.
+      #
+      # @return [Array<Cloudtasker::Middleware::Chain::Entry>] The updated list of middlewares
+      #
+      def clear
+        entries.clear
+      end
+
+      #
+      # Invoke the chain of middlewares.
+      #
+      # @param [Array<any>] *args The args to pass to each middleware.
+      #
+      def invoke(*args)
+        return yield if empty?
+
+        chain = retrieve.dup
+        traverse_chain = lambda do
+          if chain.empty?
+            yield
+          else
+            chain.shift.call(*args, &traverse_chain)
+          end
+        end
+        traverse_chain.call
+      end
+    end
+
+    # Middleware list item.
+    class Entry
+      attr_reader :klass, :args
+
+      #
+      # Build a new entry.
+      #
+      # @param [Class] klass The middleware class.
+      # @param [Array<any>] *args The list of arguments for the middleware.
+      #
+      def initialize(klass, *args)
+        @klass = klass
+        @args = args
+      end
+
+      #
+      # Return an instantiated middleware.
+      #
+      # @return [Any] The instantiated middleware.
+      #
+      def make_new
+        @klass.new(*@args)
+      end
+    end
+  end
+end

data/lib/cloudtasker/redis_client.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'redis'
+
+module Cloudtasker
+  # A wrapper with helper methods for redis
+  module RedisClient
+    module_function
+
+    # Suffix added to cache keys when locking them
+    LOCK_KEY_SUFFIX = 'lock'
+
+    #
+    # Return the underlying redis client.
+    #
+    # @return [Redis] The redis client.
+    #
+    def client
+      @client ||= Redis.new(Cloudtasker.config.redis || {})
+    end
+
+    #
+    # Get a cache entry and parse it as JSON.
+    #
+    # @param [String, Symbol] key The cache key to fetch.
+    #
+    # @return [Hash, Array] The content of the cache key, parsed as JSON.
+    #
+    def fetch(key)
+      return nil unless (val = client.get(key.to_s))
+
+      JSON.parse(val, symbolize_names: true)
+    rescue JSON::ParserError
+      nil
+    end
+
+    #
+    # Write a cache entry as JSON.
+    #
+    # @param [String, Symbol] key The cache key to write.
+    # @param [Hash, Array] content The content to write.
+    #
+    # @return [String] Redis response code.
+    #
+    def write(key, content)
+      client.set(key.to_s, content.to_json)
+    end
+
+    #
+    # Acquire a lock on a cache entry.
+    #
+    # @example
+    #   RedisClient.with_lock('foo')
+    #     content = RedisClient.fetch('foo')
+    #     RedisClient.set(content.merge(bar: 'bar).to_json)
+    #   end
+    #
+    # @param [String] cache_key The cache key to access.
+    #
+    def with_lock(cache_key)
+      return nil unless cache_key
+
+      # Wait to acquire lock
+      lock_key = [cache_key, LOCK_KEY_SUFFIX].join('/')
+      true until client.setnx(lock_key, true)
+
+      # yield content
+      yield
+    ensure
+      client.del(lock_key)
+    end
+
+    #
+    # Clear all redis keys
+    #
+    # @return [Integer] The number of keys deleted
+    #
+    def clear
+      all_keys = keys
+      return 0 if all_keys.empty?
+
+      # Delete all keys
+      del(*all_keys)
+    end
+
+    #
+    # Delegate all methods to the redis client.
+    #
+    # @param [String, Symbol] name The method to delegate.
+    # @param [Array<any>] *args The list of method arguments.
+    # @param [Proc] &block Block passed to the method.
+    #
+    # @return [Any] The method return value
+    #
+    def method_missing(name, *args, &block)
+      if client.respond_to?(name)
+        client.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    #
+    # Check if the class respond to a certain method.
+    #
+    # @param [String, Symbol] name The name of the method.
+    # @param [Boolean] include_private Whether to check private methods or not. Default to false.
+    #
+    # @return [Boolean] Return true if the class respond to this method.
+    #
+    def respond_to_missing?(name, include_private = false)
+      client.respond_to?(name) || super
+    end
+  end
+end