cosmonats 0.1.0

data/lib/cosmo.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "cosmo/utils/hash"
+require "cosmo/utils/json"
+require "cosmo/utils/string"
+require "cosmo/utils/signal"
+require "cosmo/utils/stopwatch"
+require "cosmo/utils/thread_pool"
+
+require "cosmo/client"
+require "cosmo/publisher"
+require "cosmo/processor"
+require "cosmo/version"
+require "cosmo/config"
+require "cosmo/logger"
+require "cosmo/job"
+require "cosmo/stream"
+require "cosmo/cli"
+require "cosmo/engine"
+
+module Cosmo
+  class Error < StandardError; end
+
+  class ArgumentError < Error; end
+
+  class NotImplementedError < Error; end
+
+  class ConfigNotFoundError < Error
+    def initialize(config_file)
+      super("No such file #{config_file}")
+    end
+  end
+
+  class StreamNotFoundError < Error
+    def initialize(stream_name)
+      super("Missing stream `#{stream_name}`")
+    end
+  end
+end

data/lib/cosmonats.rb

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

data/sig/cosmo/cli.rbs

@@ -0,0 +1,25 @@
+module Cosmo
+  class CLI
+    self.@instance: CLI
+
+    def self.run: () -> void
+
+    def self.instance: -> CLI
+
+    def self.banner: () -> ::String
+
+    def run: () -> void
+
+    private
+
+    def parse: () -> [Hash[Symbol, untyped], ::String?, Hash[Symbol, untyped]]
+
+    def load_config: (::String? path) -> void
+
+    def require_files: (::String? path) -> void
+
+    def flags_parser: (Hash[Symbol, untyped] flags) -> untyped
+
+    def options_parser: (::String? command, Hash[Symbol, untyped] options) -> untyped
+  end
+end

data/sig/cosmo/client.rbs

@@ -0,0 +1,30 @@
+module Cosmo
+  class Client
+    self.@instance: Client
+    @nc: untyped
+    @js: untyped
+
+    def self.instance: () -> Client
+
+    attr_reader nc: untyped
+    attr_reader js: untyped
+
+    def initialize: (?nats_url: ::String) -> void
+
+    def publish: (::String subject, ::String payload, **untyped params) -> untyped
+
+    def subscribe: (::String | Array[::String] subject, ::String consumer_name, Hash[Symbol, untyped] config) -> untyped
+
+    def stream_info: (::String | Symbol name) -> untyped
+
+    def create_stream: (::String | Symbol name, Hash[Symbol, untyped] config) -> untyped
+
+    def delete_stream: (::String | Symbol name, Hash[Symbol, untyped] params) -> untyped
+
+    def list_streams: -> Array[::String]
+
+    def get_message: (::String | Symbol name, Integer seq) -> NATS::JetStream::API::RawStreamMsg
+
+    def close: -> void
+  end
+end

data/sig/cosmo/config.rbs

@@ -0,0 +1,48 @@
+module Cosmo
+  class Config
+    NANO: Integer
+    DEFAULT_PATH: ::String
+
+    self.@instance: Config
+    self.@system: Hash[Symbol, untyped]
+    @config: Hash[Symbol, untyped]?
+    @system: Hash[Symbol, untyped]
+    @defaults: Hash[Symbol, untyped]
+
+    def self.instance: () -> Config
+
+    def self.system: () -> Hash[Symbol, untyped]
+
+    def self.parse_file: (::String path) -> Hash[Symbol, untyped]
+
+    def self.normalize!: (Hash[Symbol, untyped] config) -> void
+
+    def self.deliver_policy: (Symbol | ::String | Time start_position) -> Hash[Symbol, ::String]
+
+    def self.[]: (Symbol key) -> untyped
+
+    def self.fetch: (Symbol key, ?untyped default) -> untyped
+
+    def self.dig: (*Symbol keys) -> untyped
+
+    def self.to_h: () -> Hash[Symbol, untyped]
+
+    def self.set: (*untyped) -> untyped
+
+    def self.load: (?::String? path) -> void
+
+    def initialize: () -> void
+
+    def []: (Symbol key) -> untyped
+
+    def fetch: (Symbol key, ?untyped default) -> untyped
+
+    def dig: (*Symbol keys) -> untyped
+
+    def to_h: () -> Hash[Symbol, untyped]
+
+    def set: (*untyped) -> untyped
+
+    def load: (?::String? path) -> void
+  end
+end

data/sig/cosmo/engine.rbs

@@ -0,0 +1,21 @@
+module Cosmo
+  class Engine
+    PROCESSORS: Hash[Symbol, Class]
+
+    self.@instance: Engine
+    @concurrency: Integer
+    @pool: Utils::ThreadPool
+    @running: untyped
+    @processors: Array[Processor]
+
+    def self.run: (*untyped) -> void
+
+    def self.instance: () -> Engine
+
+    def initialize: () -> void
+
+    def run: (::String? type) -> void
+
+    def shutdown: () -> void
+  end
+end

data/sig/cosmo/job/data.rbs

@@ -0,0 +1,35 @@
+module Cosmo
+  module Job
+    class Data
+      DEFAULTS: { stream: Symbol, retry: Integer | bool, dead: bool }
+
+      @class_name: ::String
+      @args: Array[untyped]
+      @options: Hash[Symbol, untyped]
+      @at: Integer?
+      @subject: ::String?
+
+      attr_reader jid: ::String
+
+      def initialize: (::String class_name, Array[untyped] args, ?Hash[Symbol, untyped]? options) -> void
+
+      def stream: (?target: bool) -> Symbol
+
+      def subject: (?target: bool) -> Array[::String]
+
+      def as_json: () -> { jid: ::String, class: ::String, args: Array[untyped], retry: Integer, dead: bool }
+
+      def to_json: (*untyped _args) -> ::String?
+
+      def to_args: () -> [::String, ::String, Hash[Symbol, untyped]]
+
+      private
+
+      def validate!: () -> void
+
+      def retries: () -> (Integer | bool)
+
+      def dead: () -> bool
+    end
+  end
+end

data/sig/cosmo/job/processor.rbs

@@ -0,0 +1,23 @@
+module Cosmo
+  module Job
+    class Processor < ::Cosmo::Processor
+      @weights: Array[Symbol]
+
+      def initialize: (Utils::ThreadPool pool, untyped running) -> void
+
+      private
+
+      def run_loop: () -> void
+
+      def setup: () -> void
+
+      def work_loop: () -> void
+
+      def schedule_loop: () -> void
+
+      def process: (Array[untyped] messages) -> void
+
+      def handle_failure: (untyped message, Hash[Symbol, untyped] data) -> void
+    end
+  end
+end

data/sig/cosmo/job.rbs

@@ -0,0 +1,35 @@
+module Cosmo
+  module Job
+    def self.included: (Class base) -> void
+
+    module ClassMethods
+      @default_options: Hash[Symbol, untyped]
+
+      def options: (?stream: Symbol?, ?retry: Integer?, ?dead: bool?) -> Hash[Symbol, untyped]
+
+      def perform: (*untyped args, ?async: bool, **untyped options) -> (::String | nil)
+
+      def perform_async: (*untyped args) -> ::String
+
+      def perform_at: (Integer | Time timestamp, *untyped args) -> ::String
+
+      def perform_in: (Integer | Float interval, *untyped args) -> ::String
+
+      def perform_sync: (*untyped args) -> void
+
+      def default_options: () -> Hash[Symbol, untyped]
+
+      private
+
+      def client: () -> Client
+    end
+
+    attr_reader jid: ::String
+
+    def jid=: (::String) -> ::String
+
+    def perform: (*untyped) -> untyped
+
+    def logger: () -> untyped
+  end
+end

data/sig/cosmo/logger.rbs

@@ -0,0 +1,39 @@
+module Cosmo
+  module Logger
+    module Context
+      KEY: Symbol
+
+      def self.with: (**untyped options) ?{ () -> void } -> (nil | Hash[Symbol, untyped])
+
+      def self.without: (*Symbol keys) -> nil
+
+      def self.current: () -> Hash[Symbol, untyped]
+    end
+
+    class BaseFormatter
+      def tid: () -> ::String
+
+      def pid: () -> Integer
+    end
+
+    class SimpleFormatter < BaseFormatter
+      def call: (::String severity, Time time, untyped _, ::String msg) -> ::String
+    end
+
+    def self.info: (::String) -> void
+
+    def self.error: (::String | Exception) -> void
+
+    def self.debug: (::String | Exception) -> void
+
+    def self.warn: (::String) -> void
+
+    def self.fatal: (::String) -> void
+
+    def self.with: (**untyped) ?{ () -> void } -> void
+
+    def self.without: (*Symbol) -> nil
+
+    def self.instance: () -> untyped
+  end
+end

data/sig/cosmo/message.rbs

@@ -0,0 +1,38 @@
+module Cosmo
+  module Stream
+    class Message
+      @msg: untyped
+      @serializer: Module
+
+      def initialize: (untyped msg, ?serializer: Module?) -> void
+
+      def subject: () -> ::String
+
+      def reply: () -> ::String?
+
+      def header: () -> Hash[::String, untyped]
+
+      def ack: () -> void
+
+      def nack: (?delay: Integer?) -> void
+
+      def term: () -> void
+
+      def data: () -> untyped
+
+      def metadata: () -> untyped
+
+      def stream_sequence: () -> Integer
+
+      def consumer_sequence: () -> Integer
+
+      def timestamp: () -> Time
+
+      def num_delivered: () -> Integer
+
+      def num_pending: () -> Integer
+
+      def in_progress: () -> void
+    end
+  end
+end

data/sig/cosmo/processor.rbs

@@ -0,0 +1,29 @@
+module Cosmo
+  class Processor
+    @pool: Utils::ThreadPool
+    @running: untyped
+    @consumers: Hash[Symbol, untyped]
+
+    def self.run: (*untyped) -> Processor
+
+    def initialize: (Utils::ThreadPool pool, untyped running) -> void
+
+    def run: () -> void
+
+    private
+
+    def run_loop: () -> void
+
+    def setup: () -> void
+
+    def process: (*untyped) -> void
+
+    def running?: () -> bool
+
+    def fetch_messages: (Symbol stream_name, batch_size: Integer, timeout: Float) ?{ (Array[untyped]) -> void } -> void
+
+    def client: () -> Client
+
+    def stopwatch: () -> Utils::Stopwatch
+  end
+end

data/sig/cosmo/publisher.rbs

@@ -0,0 +1,21 @@
+module Cosmo
+  class Publisher
+    @client: Client
+
+    def self.instance: () -> Publisher
+
+    def self.publish: (::String subject, untyped data, ?serializer: Module?, **untyped options) -> bool
+
+    def self.publish_job: (Job::Data data) -> ::String
+
+    def self.publish_batch: (::String subject, Array[untyped] batch, **untyped options) -> void
+
+    def initialize: () -> void
+
+    def publish: (::String subject, untyped data, ?serializer: Module?, **untyped options) -> untyped
+
+    def publish_job: (Job::Data data) -> ::String
+
+    def publish_batch: (::String subject, Array[untyped] batch, **untyped options) -> void
+  end
+end

data/sig/cosmo/stream/data.rbs

@@ -0,0 +1,7 @@
+module Cosmo
+  module Stream
+    class Data
+      DEFAULTS: Hash[Symbol, Integer | Hash[Symbol, untyped]]
+    end
+  end
+end

data/sig/cosmo/stream/processor.rbs

@@ -0,0 +1,26 @@
+module Cosmo
+  module Stream
+    class Processor < ::Cosmo::Processor
+      @configs: Hash[Symbol, Hash[Symbol, untyped]]
+      @processors: Hash[Symbol, untyped]
+
+      def initialize: (Utils::ThreadPool pool, untyped running) -> void
+
+      private
+
+      def run_loop: () -> void
+
+      def setup: () -> void
+
+      def work_loop: () -> void
+
+      def process: (Symbol stream_name, Array[untyped] messages) -> void
+
+      def setup_configs: () -> void
+
+      def setup_processors: () -> void
+
+      def setup_consumers: () -> void
+    end
+  end
+end

data/sig/cosmo/stream/serializer.rbs

@@ -0,0 +1,13 @@
+module Cosmo
+  module Stream
+    module Serializer
+      def self.serialize: (untyped data) -> ::String?
+
+      def self.deserialize: (::String payload) -> untyped
+
+      def deserialize: (::String payload) -> untyped
+
+      def serialize: (untyped data) -> ::String?
+    end
+  end
+end

data/sig/cosmo/stream.rbs

@@ -0,0 +1,38 @@
+module Cosmo
+  module Stream
+    def self.included: (Class base) -> void
+
+    module ClassMethods
+      @default_options: Hash[Symbol, untyped]
+
+      def options: (
+        ?stream: Symbol?,
+        ?consumer_name: ::String?,
+        ?batch_size: Integer?,
+        ?start_position: (Symbol | ::String | Time)?,
+        ?consumer: Hash[Symbol, untyped]?,
+        ?publisher: Hash[Symbol, untyped]?
+      ) -> Hash[Symbol, untyped]
+
+      def publish: (untyped data, ?subject: ::String?, **untyped options) -> bool
+
+      def default_options: () -> Hash[Symbol, untyped]
+
+      def register: () -> void
+    end
+
+    def process: (Array[Message] messages) -> void
+
+    def process_batch: (Array[Message] messages) -> void
+
+    def process_many: (Array[Message] messages) -> void
+
+    def process_one: () -> void
+
+    def logger: () -> untyped
+
+    def message: () -> Message?
+
+    def publish: (untyped data, ::String subject, **untyped options) -> bool
+  end
+end

data/sig/cosmo/utils/hash.rbs

@@ -0,0 +1,25 @@
+module Cosmo
+  module Utils
+    module Hash
+      def self.symbolize_keys!: (untyped obj) -> (::Hash[Symbol, untyped] | Array[untyped] | untyped)
+
+      def self.dup: [T] (T hash) -> T
+
+      def self.keys?: (::Hash[untyped, untyped] hash, *untyped keys) -> bool
+
+      def self.set: (::Hash[untyped, untyped] hash, *untyped keys, value: untyped) -> untyped
+
+      def self.merge: (::Hash[untyped, untyped] hash1, ::Hash[untyped, untyped]? hash2) -> ::Hash[untyped, untyped]
+
+      def symbolize_keys!: (untyped obj) -> (::Hash[Symbol, untyped] | Array[untyped] | untyped)
+
+      def dup: [T] (T hash) -> T
+
+      def keys?: (::Hash[untyped, untyped] hash, *untyped keys) -> bool
+
+      def set: (::Hash[untyped, untyped] hash, *untyped keys, value: untyped) -> untyped
+
+      def merge: (::Hash[untyped, untyped] hash1, ::Hash[untyped, untyped]? hash2) -> ::Hash[untyped, untyped]
+    end
+  end
+end

data/sig/cosmo/utils/json.rbs

@@ -0,0 +1,13 @@
+module Cosmo
+  module Utils
+    module Json
+      def self.parse: (::String value, ?default: untyped?, ?symbolize_names: bool, **untyped options) -> untyped
+
+      def self.dump: (untyped value, ?default: untyped?) -> ::String?
+
+      def parse: (::String value, ?default: untyped?, ?symbolize_names: bool, **untyped options) -> untyped
+
+      def dump: (untyped value, ?default: untyped?) -> ::String?
+    end
+  end
+end

data/sig/cosmo/utils/signal.rbs

@@ -0,0 +1,15 @@
+module Cosmo
+  module Utils
+    class Signal
+      @queue: Queue[Symbol]
+
+      def self.trap: (*Symbol signals) -> Signal
+
+      def initialize: (*Symbol signals) -> void
+
+      def push: (Symbol) -> void
+
+      def wait: () -> Symbol
+    end
+  end
+end

data/sig/cosmo/utils/stopwatch.rbs

@@ -0,0 +1,19 @@
+module Cosmo
+  module Utils
+    class Stopwatch
+      @started_at: Float
+
+      def initialize: () -> void
+
+      def elapsed_millis: () -> Float
+
+      def elapsed_seconds: () -> Float
+
+      def reset: () -> void
+
+      private
+
+      def clock_time: () -> Float
+    end
+  end
+end

data/sig/cosmo/utils/string.rbs

@@ -0,0 +1,13 @@
+module Cosmo
+  module Utils
+    module String
+      def self.underscore: (::String | Symbol value) -> ::String
+
+      def self.safe_constantize: (::String value) -> Class?
+
+      def underscore: (::String | Symbol value) -> ::String
+
+      def safe_constantize: (::String value) -> Class?
+    end
+  end
+end

data/sig/cosmo/utils/thread_pool.rbs

@@ -0,0 +1,18 @@
+module Cosmo
+  module Utils
+    class ThreadPool
+      @mutex: Thread::Mutex
+      @available: Integer
+      @cond: Thread::ConditionVariable
+      @pool: untyped
+
+      def initialize: (Integer concurrency) -> void
+
+      def post: () { () -> void } -> void
+
+      def shutdown: () -> void
+
+      def wait_for_termination: (Integer? timeout) -> bool
+    end
+  end
+end

data/sig/cosmo.rbs

@@ -0,0 +1,20 @@
+module Cosmo
+  VERSION: ::String
+
+  class Error < StandardError
+  end
+
+  class ArgumentError < Error
+  end
+
+  class NotImplementedError < Error
+  end
+
+  class ConfigNotFoundError < Error
+    def initialize: (::String config_file) -> void
+  end
+
+  class StreamNotFoundError < Error
+    def initialize: (::String stream_name) -> void
+  end
+end