cosmonauts 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54700678b007fd3f607a4572749a5d9bac998b0f4d5ace9f2a72f5e19dbe41c4
+  data.tar.gz: a9f158bdcec30f9e01a8296b4b6c26f4030b51ebc0e330b1a6db18495ce8ed8f
+SHA512:
+  metadata.gz: 25811708dd72f75f930dafad246a9242ba3208b03cf28ff6abb49830b6ce529a7439dc05440c744a43ac04938690599bdf5b87ca3a8b664f12bf3b5fef41028d
+  data.tar.gz: 4f1385fe59157d28c1e4fc420ca61ef51a2811395d92b828b26dc8ea569ce23d87c57ceb8b808df9e1897360b1aa2bd17fb825dfb7398b649d21a03680d373b2

data/LICENSE.txt

@@ -0,0 +1,169 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+
+Copyright (c) BitsBeam LLC
+
+https://www.gnu.org/licenses/lgpl-3.0.txt

data/README.md

@@ -0,0 +1,3 @@
+# Cosmo
+
+Background jobs processing for Ruby

data/lib/cosmo/cli.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "optparse"
+
+module Cosmo
+  class CLI
+    def self.run
+      new.run
+    end
+
+    def run
+      options = parse
+      load_config(options)
+      puts self.class.banner
+      create_streams
+      run_processor
+    end
+
+    private
+
+    def parse
+      options = {}
+      parser = option_parser(options)
+      parser.parse!(ARGV.dup)
+      options
+    end
+
+    def load_config(options)
+      Config.load_config(options[:config_file])
+    end
+
+    def create_streams
+      Config.instance[:streams].each do |name, config|
+        Client.instance.maybe_create_stream(name, config)
+      end
+    end
+
+    def run_processor
+      Processor.run
+    end
+
+    def option_parser(options)
+      parser = OptionParser.new do |o|
+        o.on "-c", "--concurrency INT", "Threads to use" do |arg|
+          options[:concurrency] = Integer(arg)
+        end
+
+        o.on "-t", "--timeout NUM", "Shutdown timeout" do |arg|
+          options[:timeout] = Integer(arg)
+        end
+
+        o.on "-C", "--config PATH", "Path to config file" do |arg|
+          options[:config_file] = arg
+        end
+
+        o.on "-s", "--setup", "Load config, create streams and exit" do
+          load_config(options)
+          create_streams
+          puts "Cosmo streams were created/updated"
+          exit(0)
+        end
+
+        o.on "-v", "--version", "Print version and exit" do
+          puts "Cosmo #{VERSION}"
+          exit(0)
+        end
+      end
+
+      parser.banner = "cosmo [options]"
+      parser.on_tail "-h", "--help", "Show help" do
+        puts parser
+        exit(1)
+      end
+
+      parser
+    end
+
+    # rubocop:disable Layout/TrailingWhitespace,Lint/IneffectiveAccessModifier
+    def self.banner
+      <<-TEXT
+                    .#%+:                                                  
+                     ==-.                                       +.         
+                       +:  .::::.                              :*-         
+                     .=%%%%%%%%%%%%%#-                                     
+                  .#%%%%%%%%##*+===+*#%%:                                  
+                :##%%%%#:  :-::...::::. -%.                                
+               +%%%**  :.             :+. -=.%:                         -  
+              *%%%%: .-%%%#             ++ ---%.    -=                :==- 
+              :%%%-  *%%%%               *- %:#+   =%%%.             .====:
+          .%@%+.##.  #%%:                -+ =-=-    *%%:  .            :=  
+          =*%%%=-#.                      :: =-:     *%-%%%%%#              
+          .%=##* #-                         %.     :%%-+++%%%:             
+           +=*+= +%.                      .*.   .=+.%%-#%%#*+:             
+            ===: =*%=                   .*+  *%+%%% -%*:%%%%%:       .     
+                 =***%*.            .:#*:  .%%*+%%%#.+%+. .          =     
+           -%#-:        -*########+   .:   +%%%=%%%*++:                    
+        .##:---.  :%%-  *: +%%%%%%%%%%%##. -#%%*= =-                       
+         *#:-: :%%%%+%%= --%%#. -#%%%%+=#-   =:            .:::::::::::::: 
+         :#- =%%%%%%%+++. +*%=-%%%%#-..       ..:::::::::::::..            
+            +***+:=***::  ==:.      ....::..                               
+         -%%%%%+%%-         ....               .     +##%%=  .#%%%%%%%#.   
+        .%%%%##=%%-               :+#%%%#. *%%%%+   -%%%%%= .%%%%%%%%%%%   
+         -+--         -=#%#+:   +%%%%%%%#. *%%%%%+  #%%%%%= =%%%*   %%%%.  
+           .-+###.  *%%%%%%%%+ -%%%%+.     *%%%%%%:*%%%%%%+ -%%%*   %%%%.  
+        .*%%%%%%%  %%%%+.=%%%# =%%%%-      *%%%%%%%%%%*%%%+ -%%%*   %%%%.  
+       =%%%%%#=:. :%%%#  .%%%#  #%%%%%%%:  +%%%-*%%%%:=%%%+ -%%%*   %%%%.  
+      -%%%%-      .%%%#   %%%%    .#%%%%%= +%%%- #%%= -%%%+ -%%%*  .%%%%.  
+      *%%%#       .%%%#.  %%%%       +%%%* +%%%-      -%%%+  #%%%###%%%*   
+      %%%%*        %%%#.  #%%%..****#####- =###-      -###+   =######*.    
+      #%%%#        #%%%*+*#%%* .########:  =#*=:                           
+      +%%%%-   .=+ .########=   :----.           .:::--====++++********### 
+      .#%#########:  :==-:          ..:--=====---::::..                    
+       .########+.         .:--=--::.                                      
+          :--.       .---:.                                                
+                 :.                                                        
+      TEXT
+    end
+    # rubocop:enable Layout/TrailingWhitespace,Lint/IneffectiveAccessModifier
+  end
+end

data/lib/cosmo/client.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "nats/client"
+
+module Cosmo
+  class Client
+    NATS_URL = ENV.fetch("NATS_URL", "nats://localhost:4222")
+
+    def self.instance
+      @instance ||= Client.new
+    end
+
+    attr_reader :client, :stream
+
+    def initialize(nats_url: NATS_URL)
+      @client = NATS.connect(nats_url)
+      @stream = @client.jetstream
+    end
+
+    def publish_message(message)
+      subject, payload, params = message.to_args
+      publish(subject, payload, **params)
+      message.jid
+    end
+
+    def publish(subject, payload, **params)
+      @stream.publish(subject, payload, **params)
+    end
+
+    def maybe_create_stream(name, config)
+      @stream.stream_info(name)
+    rescue NATS::JetStream::Error::NotFound
+      @stream.add_stream(name: name, **config)
+    end
+  end
+end

data/lib/cosmo/config.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "forwardable"
+
+module Cosmo
+  class Config
+    extend Forwardable
+
+    class << self
+      extend Forwardable
+
+      delegate %i[[] fetch key? dig] => :instance
+    end
+
+    def self.load_config(path = nil)
+      raise ConfigNotFoundError, path if path && !File.exist?(path)
+
+      unless path
+        default_path = File.expand_path("config/cosmo.yml")
+        path = default_path if File.exist?(default_path)
+      end
+      return unless path
+
+      config = parse_file(path)
+      instance.merge!(config)
+    end
+
+    def self.parse_file(path)
+      YAML.load_file(path, aliases: true).tap { normalize!(_1) }
+    end
+
+    def self.normalize!(config)
+      Utils::Hash.symbolize_keys!(config)
+      config[:streams].each_key do |name|
+        c = config[:streams][name]
+        c[:max_age] = c[:max_age].to_i * 1_000_000_000 if c[:max_age]
+        c[:duplicate_window] = c[:duplicate_window].to_i * 1_000_000_000 if c[:duplicate_window]
+        c[:subjects] = c[:subjects].map { |s| format(s, name: name) } if c[:subjects]
+        c[:consumer] = c[:consumer].dup if c[:consumer]
+        c[:consumer][:name] = format(c.dig(:consumer, :name), name: name) if c.dig(:consumer, :name)
+      end
+    end
+
+    def self.instance
+      @instance ||= new
+    end
+
+    delegate %i[[] []= fetch key? merge! dig] => :@config
+
+    def initialize
+      @config = self.class.parse_file(File.expand_path("defaults.yml", __dir__)).tap { _1.delete(:default) }
+    end
+  end
+end

data/lib/cosmo/defaults.yml

@@ -0,0 +1,48 @@
+timeout: 5
+max_retries: 3
+
+default: &default
+  storage: file
+  retention: workqueue
+  duplicate_window: 120 # 2m
+  discard: old
+  allow_direct: true
+  subjects:
+    - jobs.%{name}.>
+  consumer:
+    ack_policy: "explicit"
+    max_deliver: 10
+    ack_wait: 30
+    name: consumer-%{name}
+
+streams:
+  critical:
+    <<: *default
+    priority: 50
+  high:
+    <<: *default
+    priority: 30
+  default:
+    <<: *default
+    priority: 15
+  low:
+    <<: *default
+    priority: 5
+  scheduled:
+    <<: *default
+  dead:
+    <<: *default
+    retention: limits
+    max_msgs: 10000
+    max_age: 604800 # 7d
+
+development:
+  verbose: false
+  concurrency: 1
+
+staging:
+  verbose: true
+  concurrency: 3
+
+production:
+  concurrency: 3

data/lib/cosmo/job.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Cosmo
+  module Job
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def options(stream: nil, retry: nil, backtrace: nil, dead: nil)
+        default_options.merge!({ stream:, retry:, backtrace:, dead: }.compact)
+      end
+
+      def perform(*args, async: true, **options)
+        message = Message.new(name, args, default_options.merge(options))
+        unless async
+          payload = Utils::Json.parse(message.to_args[1])
+          raise ArgumentError, "Cannot parse message payload" unless payload
+
+          new.perform(*payload[:args])
+          return
+        end
+
+        client.publish_message(message)
+      end
+
+      def perform_async(*args)
+        perform(*args)
+      end
+
+      def perform_at(timestamp, *args)
+        perform(*args, at: timestamp)
+      end
+
+      def perform_in(interval, *args)
+        perform(*args, in: interval)
+      end
+
+      def perform_sync(*args)
+        perform(*args, async: false)
+      end
+
+      def default_options
+        @default_options ||= (superclass.respond_to?(:default_options) ? superclass.default_options : Message::DEFAULTS).dup
+      end
+
+      private
+
+      def client
+        @client ||= Cosmo::Client.instance
+      end
+    end
+
+    def perform(...)
+      raise NotImplementedError, "#{self.class}#perform must be implemented"
+    end
+
+    def jid
+      Thread.current[:cosmo_jid]
+    end
+  end
+end

data/lib/cosmo/message.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Cosmo
+  class Message
+    DEFAULTS = { stream: :default, retry: 3, backtrace: false, dead: true }.freeze
+
+    attr_reader :jid
+
+    def initialize(class_name, args, options = nil)
+      @class_name = class_name
+      @args = args
+      @options = Hash(options)
+      validate!
+
+      @at = @options[:at].to_i if @options[:at]
+      @at ||= Time.now.to_i + @options[:in].to_i if @options[:in]
+
+      @jid = SecureRandom.hex(12)
+    end
+
+    def stream(target: false)
+      return @options[:stream] if target
+
+      @at ? :scheduled : @options[:stream]
+    end
+
+    def subject(target: false)
+      ["jobs", stream(target:), Utils::String.underscore(@class_name)]
+    end
+
+    def as_json
+      {
+        jid: jid,
+        class: @class_name,
+        args: @args,
+        retry: @options[:retry] || DEFAULTS[:retry]
+      }
+    end
+
+    def to_json(*_args)
+      Utils::Json.dump(as_json)
+    end
+
+    def to_args
+      headers = { "Nats-Msg-Id" => jid }
+      if @at
+        headers.merge!("X-Execute-At" => @at.to_i,
+                       "X-Stream" => stream(target: true),
+                       "X-Subject" => subject(target: true).join("."))
+      end
+      [subject.join("."), to_json, { stream: stream, header: headers }]
+    end
+
+    private
+
+    def validate!
+      raise ArgumentError, ":stream is not provided" unless @options[:stream]
+    end
+  end
+end

data/lib/cosmo/processor.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+
+module Cosmo
+  class Processor
+    FETCH_TIMEOUT = ENV.fetch("COSMO_FETCH_TIMEOUT", 0.1).to_f
+
+    def self.run
+      new.run
+    end
+
+    def initialize(streams: ["default"])
+      @concurrency = Config.fetch(:concurrency, 1)
+      @pool = Utils::ThreadPool.new(@concurrency)
+      @running = false
+      @consumers = {}
+    end
+
+    def run
+      setup_consumers
+
+      @running = true
+      Thread.new { work_loop }
+      Thread.new { schedule_loop }
+      sleep
+    end
+
+    private
+
+    def setup_consumers
+      Config[:streams].each_key do |name|
+        config = Config.dig(:streams, name, :consumer)
+        subject = Config.dig(:streams, name, :subjects, 0)
+        @consumers[name] = Client.instance.stream.pull_subscribe(subject, config[:name], config: config)
+      end
+    end
+
+    def work_loop
+      weighted = Config[:streams].filter_map { |n, c| [n, c[:priority]] if c[:priority] }
+                                 .to_h.flat_map { |p, w| [p] * w }
+
+      while @running
+        weighted.shuffle.each do |name|
+          break unless @running
+
+          begin
+            message = @consumers[name].fetch(1, timeout: FETCH_TIMEOUT)
+            @pool.post { process_job(message.first) }
+          rescue NATS::Timeout
+            # No messages, continue
+          rescue StandardError => e
+            puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+          rescue Exception => e # rubocop:disable Lint/RescueException, Lint/DuplicateBranch
+            # Unexpected error!
+            puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+          end
+
+          break unless @running
+        end
+      end
+    end
+
+    def schedule_loop
+      while @running
+        break unless @running
+
+        begin
+          now = Time.now.to_i
+          messages = @consumers[:scheduled].fetch(1, timeout: FETCH_TIMEOUT)
+          messages.each do |message|
+            headers = message.header.except("X-Stream", "X-Subject", "X-Execute-At", "Nats-Expected-Stream")
+            stream, subject, execute_at = message.header.values_at("X-Stream", "X-Subject", "X-Execute-At")
+            headers["Nats-Expected-Stream"] = stream
+            execute_at = execute_at.to_i
+
+            if now >= execute_at
+              Client.instance.publish(subject, message.data, headers: headers)
+              message.ack
+            else
+              delay_ns = (execute_at - now) * 1_000_000_000
+              message.nak(delay: delay_ns)
+            end
+          end
+        rescue NATS::Timeout
+          # No messages, continue
+        end
+
+        break unless @running
+      end
+    end
+
+    def process_job(message)
+      puts "#perform start #{message.inspect}"
+      job = Utils::Json.parse(message.data)
+      raise ArgumentError, "malformed payload" unless job
+
+      worker_class = Utils::String.safe_constantize(job[:class])
+      raise ArgumentError, "#{job[:class]} class not found" unless job
+
+      Thread.current[:cosmo_jid] = job[:jid]
+      worker_class.new.perform(*job[:args])
+      message.ack
+    rescue StandardError => e
+      handle_failure(message, job, e)
+    ensure
+      Thread.current[:cosmo_jid] = nil
+    end
+
+    def handle_failure(message, job, error)
+      puts "Error happened for #{job.inspect} with #{error.class}: #{error.message}"
+      attempts = message.metadata.num_delivered
+      max_attempts = job[:retry] + 1
+
+      if attempts >= max_attempts
+        # Dead letter - ack and move on
+        # Could publish to jobs.dead for DLQ # msg.ack
+        message.term
+        puts "Job #{job[:jid]} failed permanently with #{error.class}: #{error.message}"
+      else
+        # NATS will auto-retry based on max_deliver
+        # NATS handles retry automatically with exponential backoff
+        delay_ns = ((attempts**4) + 15) * 1_000_000_000
+        message.nak(delay: delay_ns)
+      end
+    end
+  end
+end

data/lib/cosmo/utils/hash.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Cosmo
+  module Utils
+    module Hash
+      module_function
+
+      def symbolize_keys!(hash)
+        hash.keys.each do |key|
+          raise ArgumentError, "key cannot be converted to symbol" unless key.respond_to?(:to_sym)
+
+          sym = key.to_sym
+          hash[sym] = hash.delete(key)
+          symbolize_keys!(hash[sym]) if hash[sym].is_a?(::Hash)
+        end
+
+        hash
+      end
+    end
+  end
+end

data/lib/cosmo/utils/json.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Cosmo
+  module Utils
+    module Json
+      module_function
+
+      def parse(value, default: nil, symbolize_names: true, **options)
+        JSON.parse(value, options.merge(symbolize_names:))
+      rescue TypeError, JSON::ParserError
+        default
+      end
+
+      def dump(value, default: nil)
+        ::JSON.generate(value)
+      rescue TypeError, JSON::NestingError
+        default
+      end
+    end
+  end
+end

data/lib/cosmo/utils/string.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Cosmo
+  module Utils
+    module String
+      module_function
+
+      def underscore(value)
+        value
+          .to_s
+          .gsub("::", "/")
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr("-", "_")
+          .downcase
+      end
+
+      def safe_constantize(class_name)
+        Object.const_get(class_name)
+      rescue NameError
+        # nop
+      end
+    end
+  end
+end

data/lib/cosmo/utils/thread_pool.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Cosmo
+  module Utils
+    # A thread pool that reuses a fixed number of threads operating off a fixed size queue.
+    # At any point, at most `num_threads` will be active processing tasks. When all threads are busy new
+    # tasks posted to the thread pool are blocked until a thread becomes available.
+    # Should a thread crash for any reason the thread will immediately be removed
+    # from the pool and replaced.
+    class ThreadPool
+      def initialize(concurrency)
+        @mutex = Mutex.new
+        @available = concurrency
+        @cond = ConditionVariable.new
+        @pool = Concurrent::FixedThreadPool.new(concurrency)
+      end
+
+      def post
+        @mutex.synchronize do
+          @cond.wait(@mutex) while @available <= 0
+          @available -= 1
+        end
+
+        @pool.post do
+          yield
+        ensure
+          @mutex.synchronize do
+            @available += 1
+            @cond.signal
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cosmo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Cosmo
+  VERSION = "0.1.0"
+end

data/lib/cosmo.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "cosmo/utils/hash"
+require "cosmo/utils/json"
+require "cosmo/utils/string"
+require "cosmo/utils/thread_pool"
+
+require "cosmo/client"
+require "cosmo/processor"
+require "cosmo/message"
+require "cosmo/version"
+require "cosmo/config"
+require "cosmo/job"
+require "cosmo/cli"
+
+module Cosmo
+  class Error < StandardError; end
+
+  class ArgumentError < Error; end
+
+  class ConfigNotFoundError < Error
+    def initialize(config_file)
+      super("No such file #{config_file}")
+    end
+  end
+end

data/lib/cosmonauts.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "cosmo"

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: cosmonauts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dmitry Vorotilin
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nats-pure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+description: Background processing at warp speed for Ruby
+email:
+- d.vorotilin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/cosmo.rb
+- lib/cosmo/cli.rb
+- lib/cosmo/client.rb
+- lib/cosmo/config.rb
+- lib/cosmo/defaults.yml
+- lib/cosmo/job.rb
+- lib/cosmo/message.rb
+- lib/cosmo/processor.rb
+- lib/cosmo/utils/hash.rb
+- lib/cosmo/utils/json.rb
+- lib/cosmo/utils/string.rb
+- lib/cosmo/utils/thread_pool.rb
+- lib/cosmo/version.rb
+- lib/cosmonauts.rb
+homepage: https://github.com/bitsbeam/cosmonauts
+licenses:
+- LGPL-3.0
+metadata:
+  homepage_uri: https://github.com/bitsbeam/cosmonauts
+  bug_tracker_uri: https://github.com/bitsbeam/cosmonauts/issues
+  documentation_uri: https://github.com/bitsbeam/cosmonauts/blob/main/README.md
+  changelog_uri: https://github.com/bitsbeam/cosmonauts/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/bitsbeam/cosmonauts
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Lightning-fast background processing
+test_files: []