soda-core 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 32e5b067cc3dfe374112b0eff7e91d3508f993ea58109bcab77f6a257d34513f
+  data.tar.gz: 12d12051cdeb103f889f4c104d68ed2d55818efe41705d18ae26ebbfa5fd98a4
+SHA512:
+  metadata.gz: 98481b769364a4cb9cafd63ae11394e631a97c5c914c94b6b3de380fab9324d6ccac4c8730f7483bb0b0bd0933de4585aa5dbc1650b8b0bf1e445b1fd56a2677
+  data.tar.gz: 1d28e5fbf250aa8c76098c2608a51df7b998369d6b9e738c3baaae06ce53ac27f79f18b3cfa16a62faf7ccc8f7c85db57d2b67e30b18f8561eca8e8d7c87a641

data/bin/soda

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
+
+require "soda"
+require "soda/cli"
+
+Soda::CLI.start

data/lib/soda.rb

@@ -0,0 +1,97 @@
+require "aws-sdk-sqs"
+require "json"
+require "logger"
+require "securerandom"
+require "set"
+
+require "soda/tools"
+
+require "soda/client"
+require "soda/fetcher"
+require "soda/logger"
+require "soda/manager"
+require "soda/middleware/chain"
+require "soda/processor"
+require "soda/queue"
+require "soda/queues/registry"
+require "soda/retrier"
+require "soda/worker"
+
+module Soda
+  DEFAULTS = {
+    concurrency: 10,
+  }
+
+  class << self
+    def logger
+      @logger ||= Soda::Logger.new(STDOUT)
+    end
+
+    def options
+      @options ||= DEFAULTS.dup
+    end
+
+    def configure_server
+      yield(self) if server?
+    end
+
+    def configure_client
+      yield(self) unless server?
+    end
+
+    def server?
+      defined?(Soda::CLI)
+    end
+
+    def sqs
+      (@sqs ||= Aws::SQS::Client.new).tap do |client|
+        yield(client) if block_given?
+      end
+    end
+
+    def sqs=(options)
+      @sqs_options = options || {}
+      @sqs         = Aws::SQS::Client.new(@sqs_options)
+    end
+
+    def sqs_options
+      @sqs_options ||= {}
+    end
+
+    def queues
+      (@queues ||= Queues::Registry.new).tap do |registry|
+        yield(registry) if block_given?
+      end
+    end
+
+    def queue(name)
+      queues.select(name).tap do |queue|
+        yield(queue) if block_given?
+      end
+    end
+
+    def default_queue!
+      queues.default!
+    end
+
+    def client_middleware
+      (@client_middleware ||= Middleware::Chain.new).tap do |chain|
+        yield(chain) if block_given?
+      end
+    end
+
+    def server_middleware
+      (@server_middleware ||= Middleware::Chain.new).tap do |chain|
+        yield(chain) if block_given?
+      end
+    end
+
+    def dump_json(hash)
+      JSON.dump(hash)
+    end
+
+    def load_json(str)
+      JSON.load(str)
+    end
+  end
+end

data/lib/soda/cli.rb

@@ -0,0 +1,146 @@
+require "optparse"
+
+module Soda
+  class CLI
+    include Tools
+
+    TERM = "TERM".freeze
+    INT  = "INT".freeze
+
+    SIGNALS = [
+      TERM,
+      INT,
+    ].freeze
+
+    def self.start
+      new.run
+    end
+
+    def initialize(argv = ARGV)
+      @argv = argv
+    end
+
+    def run
+      build_options
+
+      if rails?
+        if Rails::VERSION::MAJOR >= 5
+          require "./config/environment.rb"
+          require "soda/rails"
+          logger.info("Loaded Rails v%s application." % ::Rails.version)
+        else
+          raise "Not compatible with Rails v%s!" % Rails.version
+        end
+      end
+
+      manager = Manager.new
+      manager.start
+
+      read, write = IO.pipe
+
+      SIGNALS.each do |signal|
+        trap(signal) do
+          write.puts(signal)
+        end
+      end
+
+      logger.info("Starting up...")
+      manager.start
+
+      while (io = IO.select([read]))
+        line, _ = io.first
+        sig = line.gets.strip
+
+        handle_signal(sig)
+      end
+    rescue Interrupt
+      logger.info("Shutting down...")
+      manager.stop
+      logger.info("👋")
+
+      exit(0)
+    end
+
+    private
+
+    attr_reader :argv, :manager
+
+    def handle_signal(signal)
+      logger.info("Received signal %s..." % signal)
+
+      case signal
+      when TERM
+      when INT
+        raise Interrupt
+      end
+    end
+
+    def build_options
+      opts    = {}
+      parser  = build_option_parser(opts)
+      parser.parse!(argv)
+
+      if (req = opts.delete(:require))
+        require(req)
+      end
+
+      if (queues_opt = opts.delete(:queues))
+        parse_queues(queues_opt)
+      end
+
+      options = Soda.options
+      options.merge!(opts)
+    end
+
+    def build_option_parser(opts)
+      OptionParser.new do |o|
+        o.on("-r", "--require [PATH]", "Location of file to require") do |val|
+          opts.merge!(require: val)
+        end
+
+        o.on("-q", "--queues [PATH]", "Queue to listen to, with optional weights") do |val|
+          opts.merge!(queues: opts.fetch(:queues, []).push(val.split(/\,+/)))
+        end
+      end
+    end
+
+    def parse_queues(opt)
+      Soda.queues do |registry|
+        opt.each do |name, weight|
+          # Find or create the queue.
+          queue = registry.select(name)
+
+          if weight
+            # Replace the queue with the same one, except mutate the options to
+            # include the specified weight.
+            registry.register(
+              queue.name,
+              queue.url,
+              queue.options.merge(weight: weight.to_i),
+            )
+          end
+        end
+
+        # For queues that are not included in the command, set their weight to
+        # zero so they can still be accessed.
+        names = opt.map(&:first)
+        registry.each do |queue|
+          unless names.include?(queue.name)
+            registry.register(
+              queue.name,
+              queue.url,
+              queue.options.merge(weight: 0),
+            )
+          end
+        end
+      end
+    end
+
+    def rails?
+      require "rails"
+      defined?(::Rails)
+    rescue LoadError
+      false
+    end
+  end
+end

data/lib/soda/client.rb

@@ -0,0 +1,38 @@
+module Soda
+  class Client
+    def push(item)
+      copy  = normalize!(item)
+      mw    = Soda.client_middleware
+
+      mw.use(item["klass"], copy, copy["queue"]) do
+        Soda.queue(copy["queue"]) do |queue|
+          queue.push_in(copy["delay"], Soda.dump_json(copy))
+        end
+      end
+    end
+
+    private
+
+    def normalize!(item)
+      item.dup.tap do |copy|
+        copy.keys.each do |key|
+          copy.merge!(String(key) => copy[key])
+        end
+
+        id      = SecureRandom.base64(10)
+        klass   = copy["klass"].to_s
+        delay   = Integer(copy["delay"]) || 0
+        queue   = copy["queue"] || Soda.default_queue!.name
+
+        # TODO: add validation
+        #
+        copy.merge!(
+          "id"    => id,
+          "klass" => klass,
+          "delay" => delay,
+          "queue" => queue,
+        )
+      end
+    end
+  end
+end

data/lib/soda/fetcher.rb

@@ -0,0 +1,83 @@
+module Soda
+  class Fetcher
+    # If there's an error fetching from a queue, we should sleep.
+    SLEEP = 10
+
+    include Tools
+
+    # Uses a weighted round robin approach to selecting which queue to use.
+    # See: https://en.wikipedia.org/wiki/Weighted_round_robin
+    def initialize
+      @mutex  = Mutex.new
+      @queues = weigh_queues
+      @paused = []
+    end
+
+    def fetch
+      unpause
+
+      queue = next!
+      if queue
+        msgs = pop(queue)
+        msgs.tap do
+          pause(queue, queue.options[:sleep]) if msgs.count.zero?
+        end
+      end
+    rescue Aws::SQS::Errors::ServiceError
+      pause(queue, SLEEP) unless queue.nil?
+
+      raise
+    end
+
+    private unless $TESTING
+
+    attr_reader :queues, :paused, :mutex
+
+    def pop(queue)
+      start = now
+      logger.debug(%(fetching from "%s") % queue.name)
+
+      queue.pop.tap do |msgs|
+        logger.debug(%(fetched %d message(s) from "%s" (%fms)) % [msgs.count, queue.name, (now - start)])
+      end
+    end
+
+    def next!
+      mutex.synchronize do
+        queues.shift.tap do |q|
+          queues.push(q) unless q.nil?
+        end
+      end
+    end
+
+    def unpause
+      mutex.synchronize do
+        paused.each do |wakeup, q|
+          if wakeup <= Time.now
+            paused.delete([wakeup, q])
+            queues.concat(weigh_queues([q]))
+
+            logger.info(%(un-paused fetching from "%s") % q.name)
+          end
+        end
+      end
+    end
+
+    def pause(queue, sleep)
+      mutex.synchronize do
+        if queues.delete(queue)
+          paused << [Time.now + sleep, queue]
+          logger.info(%(paused fetching from "%s" for %d second(s)) % [queue.name, sleep])
+        end
+      end
+    end
+
+    def weigh_queues(queues = Soda.queues)
+      [].tap do |weighted|
+        queues.each do |queue|
+          weighted.concat([queue] * queue.weight)
+        end
+      end
+    end
+  end
+end

data/lib/soda/logger.rb

@@ -0,0 +1,69 @@
+module Soda
+  class Logger < ::Logger
+    class Formatter
+      include Tools
+
+      CONTEXT_KEY = :_soda_log_context
+
+      def call(severity, time, _, message)
+        context = format_context(severity, time)
+
+        "%s %s\n" % [context, message]
+      end
+
+      def context
+        Thread.current[CONTEXT_KEY] || []
+      end
+
+      def context=(ctx)
+        Thread.current[CONTEXT_KEY] = ctx
+      end
+
+      private
+
+      def format_context(severity, time)
+        ctx   = [[:tid, tid]].concat(context)
+        parts = ctx.map { |k, v| "[%s: %s]" % [k, v] }
+        "[%s] %s %s" % [time.iso8601(3), parts.join(" "), severity]
+      end
+    end
+
+    def initialize(*args, **kwargs)
+      super
+
+      self.formatter = Formatter.new
+    end
+
+    def with(*context)
+      ctx, formatter.context =
+        formatter.context, (formatter.context + context)
+
+      yield
+    ensure
+      formatter.context = ctx
+    end
+
+    class JobLogger
+      include Tools
+
+      def initialize(logger = Soda.logger)
+        @logger = logger
+      end
+
+      def with(job_hash)
+        logger.with([:worker, job_hash["klass"]], [:jid, job_hash["id"]]) do
+          start = now
+          logger.info("start")
+
+          yield
+
+          logger.info("finish (%fms)" % (now - start))
+        end
+      end
+
+      private
+
+      attr_reader :logger
+    end
+  end
+end

data/lib/soda/manager.rb

@@ -0,0 +1,53 @@
+module Soda
+  class Manager
+    attr_reader :fetcher
+
+    def initialize
+      @workers  = Set.new
+      @fetcher  = Fetcher.new
+      @mutex    = Mutex.new
+      @shutdown = false
+
+      count = Soda.options[:concurrency]
+      count.times do
+        @workers << Processor.new(self)
+      end
+    end
+
+    def start
+      workers.each(&:start)
+    end
+
+    def stop
+      shutdown!
+
+      workers.each(&:stop)
+      workers.each(&:finish)
+    end
+
+    # A processor will die on failed job execution. Replace it with a new one.
+    def on_died(worker)
+      mutex.synchronize do
+        workers.delete(worker)
+
+        unless shutdown?
+          workers << (processor = Processor.new(self))
+
+          processor.start
+        end
+      end
+    end
+
+    private unless $TESTING
+
+    attr_reader :workers, :mutex
+
+    def shutdown!
+      @shutdown = true
+    end
+
+    def shutdown?
+      @shutdown
+    end
+  end
+end

data/lib/soda/middleware/chain.rb

@@ -0,0 +1,57 @@
+module Soda
+  module Middleware
+    class Chain
+      include Enumerable
+
+      Entry = Struct.new(:klass, :args) do
+        def build
+          klass.new(*args)
+        end
+      end
+
+      def initialize
+        @entries = []
+      end
+
+      def each
+        entries.each(&:block)
+      end
+
+      def add(klass, *args)
+        remove(klass)
+        entries << Entry.new(klass, args)
+      end
+
+      def remove(klass)
+        entries.delete_if { |entry| entry.klass == klass }
+      end
+
+      def insert_at(index, klass, *args)
+        entries.insert(index, Entry.new(klass, args))
+      end
+
+      def use(*args)
+        traverse(entries.dup, args) do
+          yield
+        end
+      end
+
+      private
+
+      attr_reader :entries
+
+      def traverse(copy, args)
+        if copy.empty?
+          yield
+        else
+          entry = copy.shift
+          inst  = entry.klass.new(*entry.args)
+
+          inst.call(*args) do
+            traverse(copy, args) { yield }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/soda/processor.rb

@@ -0,0 +1,120 @@
+module Soda
+  class Processor
+    include Tools
+
+    def initialize(manager)
+      @manager      = manager
+      @retrier      = Retrier.new
+      @job_logger   = Soda::Logger::JobLogger.new
+      @stopped      = false
+    end
+
+    def start
+      @thread ||= Thread.new(&method(:run))
+    end
+
+    def stop
+      @stopped = true
+    end
+
+    def finish
+      thread.join
+    end
+
+    private unless $TESTING
+
+    attr_reader :manager, :retrier, :job_logger, :thread
+
+    def stopped?
+      @stopped
+    end
+
+    def run
+      until stopped?
+        msgs = fetch
+        msgs.each(&method(:process))
+      end
+    rescue Exception => ex
+      manager.on_died(self)
+    end
+
+    def fetch
+      fetcher = manager.fetcher
+      fetcher.fetch
+    rescue => ex
+      handle_exception(ex)
+
+      raise
+    end
+
+    def process(msg)
+      if (job_hash = parse_job(msg.str))
+        job_logger.with(job_hash) do
+          reloader.wrap do
+            execute(job_hash, msg)
+          end
+        end
+      else
+        # We can't process the work because the JSON is invalid, so we have to
+        # acknowledge the message (thus removing it) and move on.
+        msg.acknowledge
+      end
+    rescue => ex
+      handle_exception(ex)
+
+      raise
+    end
+
+    def execute(job_hash, msg)
+      queue   = msg.queue
+      klass   = job_hash["klass"]
+      worker  = constantize(klass)
+
+      retrier.retry(job_hash, msg) do
+        middleware = Soda.server_middleware
+        middleware.use(worker, job_hash, queue.name, msg) do
+          instance = worker.new(job_hash)
+          instance.perform(*job_hash["args"])
+        end
+
+        msg.acknowledge
+      end
+    end
+
+    def parse_job(str)
+      Soda.load_json(str).tap do |job_hash|
+        # ensure the JSON has an `args` and a `klass` value before considering
+        # the message valid.
+        job_hash.fetch("klass") && job_hash.fetch("args")
+      end
+    rescue => ex
+      nil
+    end
+
+    # For now, don't do much - just log out the error
+    # TODO: make this more robust. Maybe support error handlers.
+    def handle_exception(ex)
+      logger.error(ex)
+    end
+
+    def constantize(str)
+      Object.const_get(str)
+    end
+
+    # To support Rails reloading from the CLI context, the following code find
+    # the Rails reloader or stubs a no-op one.
+    class StubReloader
+      def wrap; yield; end
+    end
+
+    def reloader
+      @reloader ||=
+        if defined?(::Soda::Rails)
+          application = ::Rails.application
+          application.reloader
+        else
+          StubReloader.new
+        end
+    end
+  end
+end

data/lib/soda/queue.rb

@@ -0,0 +1,104 @@
+module Soda
+  class Queue
+    include Tools
+
+    Message = Struct.new(:queue, :contents) do
+      include Tools
+
+      FIRST_RECEIVED_AT_ATTRIBUTE = "ApproximateFirstReceiveTimestamp".freeze
+      RECEIVE_COUNT_ATTRIBUTE     = "ApproximateReceiveCount".freeze
+
+      def receipt; contents.receipt_handle; end
+      def str;     contents.body; end
+
+      def first_received_at
+        int = contents.attributes[FIRST_RECEIVED_AT_ATTRIBUTE]
+        Time.at(int.to_f / 1_000)
+      end
+
+      def receive_count
+        contents.attributes[RECEIVE_COUNT_ATTRIBUTE].to_i
+      end
+
+      # This is a bit of an inference: if we've received the message more than
+      # one, we can assume it's a retry. This is useful for handling batches.
+      def retry?
+        receive_count > 1
+      end
+
+      def acknowledge
+        sqs do |client|
+          logger.with([:receipt, receipt]) do
+            client.delete_message(
+              queue_url:      queue.lazy_url,
+              receipt_handle: receipt,
+            )
+
+            logger.debug("acknowleged")
+          end
+        end
+      end
+    end
+
+    attr_reader :name, :url, :options
+
+    DEFAULTS = {
+      weight:   1,
+      sleep:    1,
+      wait:     1,
+      timeout:  25,
+    }
+
+    def initialize(name, url, options = {})
+      @name     = name
+      @url      = url
+      @options  = DEFAULTS.dup.merge(options)
+    end
+
+    %i[weight sleep wait timeout].each do |method|
+      define_method(method) do
+        options.fetch(method)
+      end
+    end
+
+    # Lazily fetch queue URL if one is not provided as part of the queue
+    # configuration.
+    def lazy_url
+      @lazy_url ||=
+        url || begin
+          resp = sqs.get_queue_url(queue_name: name)
+          resp.queue_url
+        end
+    end
+
+    def push_in(interval, str)
+      sqs do |client|
+        client.send_message(
+          queue_url:      lazy_url,
+          message_body:   str,
+          delay_seconds:  interval,
+        )
+      end
+    end
+
+    def pop
+      resp = sqs.receive_message(
+        queue_url:               lazy_url,
+        attribute_names:         %w[All],
+        message_attribute_names: %w[All],
+        wait_time_seconds:       wait,
+        visibility_timeout:      timeout,
+      )
+
+      Enumerator.new do |yielder|
+        resp.messages.each do |msg|
+          yielder.yield(Message.new(self, msg))
+        end
+      end
+    end
+
+    def ==(other)
+      other.name == name
+    end
+  end
+end

data/lib/soda/queues/registry.rb

@@ -0,0 +1,74 @@
+module Soda
+  module Queues
+    class Registry
+      include Enumerable
+
+      def initialize
+        @entries = []
+        @mutex   = Mutex.new
+      end
+
+      def each(&block)
+        entries.each(&block)
+      end
+
+      def register(name, url = nil, **options)
+        if include?(name)
+          replace(name, url, **options)
+        else
+          mutex.synchronize do
+            queue = Soda::Queue.new(name, url, options)
+            queue.tap do
+              entries << queue
+            end
+          end
+        end
+      end
+
+      def include?(name)
+        entries.any? do |entry|
+          entry.name == name
+        end
+      end
+
+      def index(name)
+        entries.find_index do |entry|
+          entry.name == name
+        end
+      end
+
+      def replace(name, url = nil, **options)
+        queue = Soda::Queue.new(name, url, options)
+        queue.tap do
+          entries[index(name)] = queue
+        end
+      end
+
+      def deregister(name, *)
+        mutex.synchronize do
+          entries.delete_if do |entry|
+            entry.name == name
+          end
+        end
+      end
+
+      # Try to find a registered queue. If one is not registered, then create a
+      # new one for the specified name (with no specified URL or options).
+      def select(name)
+        entry = entries.detect { |ent| ent.name == name }
+        (entry = register(name)) if entry.nil?
+
+        entry
+      end
+
+      # TODO: improve error
+      def default!
+        entries.first or raise
+      end
+
+      private
+
+      attr_reader :entries, :mutex
+    end
+  end
+end

data/lib/soda/rails.rb

@@ -0,0 +1,7 @@
+module Soda
+  module Rails
+    class Engine < ::Rails::Engine
+      # TODO: define AJ integration
+    end
+  end
+end

data/lib/soda/retrier.rb

@@ -0,0 +1,50 @@
+module Soda
+  class Retrier
+    include Tools
+
+    # AWS enforces a 12-hour maximum visibility timeout. If this is surpassed,
+    # the job is dead.
+    MAX_TIMEOUT = 60 * 60 * 12
+
+    def retry(job_hash, msg)
+      yield
+    rescue => ex
+      if postpone?(job_hash, msg)
+        postpone(msg)
+      end
+
+      raise
+    end
+
+    private
+
+    def postpone?(job_hash, msg)
+      ret = job_hash["retry"]
+
+      if ret.is_a?(Numeric)
+        ret < msg.receive_count
+      else
+        ret
+      end
+    end
+
+    def postpone(msg)
+      sqs do |client|
+        timeout =
+          (Time.now - msg.first_received_at).to_i + (msg.receive_count ** 2)
+
+        if timeout <= MAX_TIMEOUT
+          client.change_message_visibility(
+            queue_url:          msg.queue.lazy_url,
+            receipt_handle:     msg.receipt,
+            visibility_timeout: timeout,
+          )
+        else
+          # This is not going to work; delete from the queue and move on. Bye
+          # for good!
+          msg.acknowledge
+        end
+      end
+    end
+  end
+end

data/lib/soda/tools.rb

@@ -0,0 +1,23 @@
+module Soda
+  module Tools
+    TID_KEY = :_soda_tid
+
+    def logger
+      ::Soda.logger
+    end
+
+    def sqs(&block)
+      ::Soda.sqs(&block)
+    end
+
+    # h/t Sidekiq
+    # https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/logger.rb#L114
+    def tid
+      Thread.current[TID_KEY] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
+    end
+
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/soda/version.rb

@@ -0,0 +1,3 @@
+module Soda
+  VERSION = "0.0.6".freeze
+end

data/lib/soda/worker.rb

@@ -0,0 +1,77 @@
+module Soda
+  module Worker
+    class Options
+      def initialize(klass, options)
+        @klass    = klass
+        @options  = options
+      end
+
+      def set(opts = {})
+        tap do
+          options.merge!(opts)
+        end
+      end
+
+      def perform_async(*args)
+        perform_in(0, *args)
+      end
+
+      def perform_in(delay, *args)
+        tap do
+          client = Soda::Client.new
+          client.push(
+            options.merge(
+              "delay" => delay,
+              "klass" => klass,
+              "args"  => args,
+            ),
+          )
+        end
+      end
+
+      private
+
+      attr_reader :klass, :options
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def set(opts = {})
+        Options.new(self, options.merge(opts))
+      end
+
+      def soda_options(opts = {})
+        options.merge!(opts)
+      end
+
+      def perform_async(*args)
+        perform_in(0, *args)
+      end
+
+      def perform_in(delay, *args)
+        tap do
+          opts = Options.new(self, options)
+          opts.perform_in(delay, *args)
+        end
+      end
+      alias_method :perform_at, :perform_in
+
+      private
+
+      def options
+        @options ||= {}
+      end
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    private
+
+    attr_reader :options
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: soda-core
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Noah Portes Chaikin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-sqs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+description: 
+email: 
+executables:
+- soda
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/soda
+- lib/soda.rb
+- lib/soda/cli.rb
+- lib/soda/client.rb
+- lib/soda/fetcher.rb
+- lib/soda/logger.rb
+- lib/soda/manager.rb
+- lib/soda/middleware/chain.rb
+- lib/soda/processor.rb
+- lib/soda/queue.rb
+- lib/soda/queues/registry.rb
+- lib/soda/rails.rb
+- lib/soda/retrier.rb
+- lib/soda/tools.rb
+- lib/soda/version.rb
+- lib/soda/worker.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A flexible job runner for Ruby.
+test_files: []