async-tools 0.2.9 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc3694f2f03f7c7845ee1c6911a3a2f2042b0d4b55c20fdef6c616e205c45c64
-  data.tar.gz: d7c56b6cb80b8dc83a041f3f53bc5b876b0f2ea6286bf6b53dd3c0173b264e7d
+  metadata.gz: 0d1ee91075ee99708de1e43d75c7184d9a23c79a0cf36291d91d7ede9314d22d
+  data.tar.gz: b49e3539aadec63fa3aeed3c3e95bb6bbeca1ef33ef3487bf406b8a28430941d
 SHA512:
-  metadata.gz: 42cc9c27e20fca3fd48287c0c0f0bd5c4176d607d540d9e3ecb5237eebecf494ffb4fe8dc9b025e85ed45771bedadfa3b227fb702a344fe11bf42e0ca212699a
-  data.tar.gz: ff2dcf6780a51aad4e220dbb0548a0757dcc603072b1c7b195b7124e9175e14a31300b349d1dfde1868020511317182ad07074499ea94835424e08ebed59e1dd
+  metadata.gz: 02e5dce453e331558d760ff45769f466192e1b95963373e23cd9668c364bc131902f3d09457363b987308326def15e841651c3311b09d1a1878c61fba03b595d
+  data.tar.gz: ab0d8f31349e0514d14ff1c232072c530658db77c6302e5af13238b8bb25cc96226e3b8d7075367653c62095dcf1ca9e64b2120a234364119ed3310e126c2a7f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    async-tools (0.2.9)
+    async-tools (0.2.10)
       async (~> 2.3)
       zeitwerk (~> 2.6)
 

data/lib/async/app/autoload_component.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Async::App::AutoloadComponent
+  def self.included(base) = base.include(Async::App::Component)
+end

data/lib/async/app/component.rb

@@ -7,5 +7,19 @@ module Async::App::Component
     base.include(Async::Logger)
   end
 
-  def run = nil
+  def start!
+    init!
+    after_init
+    run!
+    after_run
+  end
+
+  def init! = nil
+  def run! = info { "Started" }
+
+  # TODO: unsubscribe from everything on stop
+  def stop! = info { "Stopped" }
+
+  def after_init = nil
+  def after_run = nil
 end

data/lib/async/app/event_logger.rb

@@ -3,7 +3,7 @@
 class Async::App::EventLogger
   include Async::App::Component
 
-  def run
+  def after_init
     bus.subscribe(/.*/) do |payload, name|
       debug { "Event #{name} received. Payload:\n\n#{payload.pretty_inspect}\n" }
     end

data/lib/async/app/injector.rb

@@ -3,7 +3,7 @@
 module Async::App::Injector
   def inject(name)
     define_method(name) do
-      $__ASYNC_APP.container[name] # rubocop:disable Style/GlobalVars
+      Async::App.instance.container[name]
     end
     private name
   end

data/lib/async/app/metrics/components_metrics_collector.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Async::App::Metrics::ComponentsMetricsCollector
+  include Async::App::TimerComponent
+  include Async::App::AutoloadComponent
+
+  def on_tick = bus.publish("metrics.updated", metrics)
+  def interval = 5
+  def run_on_start = true
+  def on_error(exception) = warn { exception }
+
+  private
+
+  def metrics
+    {
+      async_app_components: { value: Async::App.instance.components.count },
+      async_app_autoloadable_components: { value: Async::App.instance.autoloadable_components.count },
+      async_app_timer_components: { value: Async::App.instance.timer_components.count }
+    }
+  end
+end

data/lib/async/app/metrics/ruby_runtime_metrics_collector.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
 class Async::App::Metrics::RubyRuntimeMetricsCollector
-  include Async::App::Component
+  include Async::App::TimerComponent
+  include Async::App::AutoloadComponent
 
-  INTERVAL = 5
+  def on_tick = bus.publish("metrics.updated", metrics)
+  def interval = 5
+  def run_on_start = true
+  def on_error(exception) = warn { exception }
 
-  def run
-    Async::Timer.new(INTERVAL, run_on_start: true, on_error: ->(e) { warn(e) }) do
-      bus.publish("metrics.updated", metrics)
-    end
-    info { "Started" }
-  end
+  private
 
   def metrics
     fibers = ObjectSpace.each_object(Fiber)

data/lib/async/app/timer_component.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Async::App::TimerComponent
+  def self.included(base)
+    base.include(Async::App::Component)
+    base.include(InstanceMethods)
+  end
+
+  module InstanceMethods
+    def init!
+      super
+      @timer = Async::Timer.new(run_on_start:, start: false, on_error: method(:on_error)) { tick! }
+    end
+
+    def run!
+      return if @timer.active?
+
+      @timer.start(interval)
+      info { "Started. Interval = #{interval}" }
+    end
+
+    def stop!
+      @timer&.stop
+      super
+    end
+
+    # TimerComponent - specific methods
+    def tick!
+      debug { "Started" }
+      on_tick
+      debug { "Finished" }
+    end
+
+    def restart!
+      @timer.restart(interval)
+      info { "Restarted. Polling interval=#{interval}" }
+    end
+
+    private
+
+    def interval = raise NotImplementedError
+    def run_on_start = raise NotImplementedError
+    def on_tick = raise NotImplementedError
+    def on_error(exception) = raise exception
+  end
+end

data/lib/async/app/{web_server → web_apps}/health_app.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-class Async::App::WebServer::HealthApp
-  include Async::App::Component
+class Async::App::WebApps::HealthApp
+  include Async::App::WebComponent
+  include Async::App::AutoloadComponent
 
   PATHS = ["/health", "/health/"].freeze
 
-  def initialize
+  def after_init
     @healthy = false
-
     bus.subscribe("health.updated") { @healthy = _1 }
   end
 

data/lib/async/app/{web_server → web_apps}/metrics_app/serializer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Async::App::WebServer::MetricsApp::Serializer
+class Async::App::WebApps::MetricsApp::Serializer
   def initialize(prefix:, store:)
     @prefix = prefix
     @store = store

data/lib/async/app/{web_server → web_apps}/metrics_app/store.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Async::App::WebServer::MetricsApp::Store
+class Async::App::WebApps::MetricsApp::Store
   include Enumerable
 
   def set(name, value:, suffix: "total", **labels)

data/lib/async/app/{web_server → web_apps}/metrics_app.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
-class Async::App::WebServer::MetricsApp
-  include Async::App::Component
+class Async::App::WebApps::MetricsApp
+  include Async::App::WebComponent
+  include Async::App::AutoloadComponent
 
   PATHS = ["/metrics", "/metrics/"].freeze
 
-  def initialize(metrics_prefix:)
+  inject :async_app_name
+
+  def after_init
     store = Store.new
-    @serializer = Serializer.new(prefix: metrics_prefix, store:)
+    @serializer = Serializer.new(prefix: async_app_name, store:)
 
     bus.subscribe("metrics.updated") do |metrics|
       metrics.each { store.set(_1, **_2) }

data/lib/async/app/web_component.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Async::App::WebComponent
+  def self.included(base)
+    base.include(Async::App::Component)
+    base.include(InstanceMethods)
+  end
+
+  module InstanceMethods
+    def run! = bus.publish(Async::App::WebServer::APP_ADDED, self)
+
+    def can_handle?(request) = raise NotImplementedError
+    def call(*) = raise NotImplementedError
+  end
+end

data/lib/async/app/web_server.rb

@@ -1,17 +1,34 @@
 # frozen_string_literal: true
 
 class Async::App::WebServer
-  include Async::Logger
+  include Async::App::Component
 
-  def initialize(metrics_prefix:, port: 8080)
-    @router = Async::App::WebServer::Router.new(
-      MetricsApp.new(metrics_prefix:),
-      HealthApp.new
-    )
+  APP_ADDED = "async-app.web_app.added"
+
+  class Router
+    def initialize
+      @apps = []
+    end
+
+    def add(app) = @apps << app
+
+    def call(request)
+      @apps.reverse_each { return Protocol::HTTP::Response[*_1.call(request)] if _1.can_handle?(request) }
+
+      Protocol::HTTP::Response[404, {}, ["Not found"]]
+    end
+  end
+
+  def initialize(port: 8080)
+    @router = Router.new
     @endpoint = Async::HTTP::Endpoint.parse("http://0.0.0.0:#{port}")
   end
 
-  def run
+  def after_init = bus.subscribe(APP_ADDED) { add_app(_1) }
+
+  def add_app(app) = @router.add(app)
+
+  def run!
     Async { Async::HTTP::Server.new(@router, @endpoint).run }
     info { "Started on #{@endpoint.url}" }
   end

data/lib/async/app.rb

@@ -1,68 +1,68 @@
 # frozen_string_literal: true
 
 class Async::App
-  extend Async::App::Injector
+  include Component
 
-  include Async::Logger
+  class << self
+    def instance = @instance = instances(self).first
 
-  inject :bus
-
-  # rubocop:disable Style/GlobalVars
-  def initialize
-    raise "only one instance of #{self.class} is allowed" if $__ASYNC_APP
+    def instances(klass) = ObjectSpace.each_object(klass)
+  end
 
-    $__ASYNC_APP = self
-    @task = Async::Task.current
+  def init!
+    raise "only one instance of #{self.class} is allowed" if instances(self.class).count > 1
 
+    @parent = Async::Task.current
     set_traps!
     init_container!
-
-    start_event_logger!
-    start_web_server!
-
-    start_runtime_metrics_collector!
-
-    run!
-
-    info { "Started" }
-    bus.publish("health.updated", true)
+    super
   rescue StandardError => e
     fatal { e }
-    stop
+    stop!
     exit(1)
   end
 
-  def container = @container ||= Dry::Container.new
-  def run! = nil
-  def container_config = {}
-  def app_name = :async_app
-
-  def stop
-    @task&.stop
-    $__ASYNC_APP = nil
-    info { "Stopped" }
+  def stop!
+    @parent&.stop(true)
+    super
   end
 
-  # rubocop:enable Style/GlobalVars
+  def container = @container ||= Dry::Container.new
+  def instances(klass) = self.class.instances(klass)
+  def components = instances(Class).select { _1.included_modules.include?(Component) }.reject { _1 <= self.class }
+  def autoloadable_components = components.select { _1.included_modules.include?(AutoloadComponent) }
+  def timer_components = components.select { _1.included_modules.include?(TimerComponent) }
 
   private
 
+  def container_config = {}
+  def async_app_name = :async_app
+
+  def run!
+    start_event_logger!
+    start_web_server!
+
+    autoload_components!
+    super
+    bus.publish("health.updated", true)
+  end
+
   def set_traps!
     trap("INT") do
       force_exit! if @stopping
       @stopping = true
       warn { "Interrupted, stopping. Press ^C once more to force exit." }
-      stop
+      stop!
     end
 
-    trap("TERM") { stop }
+    trap("TERM") { stop! }
   end
 
   def init_container!
-    {
-      bus: Async::Bus.new,
-      **container_config
-    }.each { container.register(_1, _2) }
+    container.register(:bus, Async::Bus.new)
+    container.register(:async_app_name, async_app_name)
+
+    container_config.each { container.register(_1, _2) }
   end
 
   def force_exit!
@@ -70,7 +70,7 @@ class Async::App
     exit(1)
   end
 
-  def start_web_server! = WebServer.new(metrics_prefix: app_name).run
-  def start_event_logger! = EventLogger.new.run
-  def start_runtime_metrics_collector! = Async::App::Metrics::RubyRuntimeMetricsCollector.new.run
+  def autoload_components! = autoloadable_components.each { _1.new.start! }
+  def start_web_server! = WebServer.new.start!
+  def start_event_logger! = EventLogger.new.start!
 end

data/lib/async/timer.rb

@@ -7,7 +7,7 @@ class Async::Timer
 
   class AlreadyStarted < Error; end
 
-  def initialize(delay, # rubocop:disable Metrics/CyclomaticComplexity,Metrics/ParameterLists
+  def initialize(delay = nil, # rubocop:disable Metrics/CyclomaticComplexity,Metrics/ParameterLists
                  repeat: true,
                  start: true,
                  run_on_start: false,
@@ -32,14 +32,16 @@ class Async::Timer
 
   def active? = @active
 
-  def restart
+  def restart(delay = @delay, run: false)
     stop
-    start
+    start(delay, run:)
   end
 
-  def start(run: false)
+  def start(delay = @delay, run: false)
     raise AlreadyStarted, "Timer already started" if active?
+    raise ArgumentError, "delay cannot be nil" if delay.nil?
 
+    @delay = delay
     @active = true
 
     @task = @parent.async do

data/lib/async/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Async # rubocop:disable Style/ClassAndModuleChildren
   module Tools
-    VERSION = "0.2.9"
+    VERSION = "0.2.10"
   end
 end

data/lib/async/tools.rb

@@ -13,8 +13,6 @@ loader.tag = File.basename(__FILE__, ".rb")
 loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
 loader.push_dir(File.expand_path("..", __dir__.to_s))
 
-loader.setup
-
 module Async
   # Your code goes here...
   module Tools # rubocop:disable Style/ClassAndModuleChildren
@@ -30,3 +28,6 @@ module Async
     end
   end
 end
+
+loader.setup
+loader.eager_load

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-tools
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.10
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-08 00:00:00.000000000 Z
+date: 2023-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -61,16 +61,19 @@ files:
 - bin/console
 - bin/setup
 - lib/async/app.rb
+- lib/async/app/autoload_component.rb
 - lib/async/app/component.rb
 - lib/async/app/event_logger.rb
 - lib/async/app/injector.rb
+- lib/async/app/metrics/components_metrics_collector.rb
 - lib/async/app/metrics/ruby_runtime_metrics_collector.rb
+- lib/async/app/timer_component.rb
+- lib/async/app/web_apps/health_app.rb
+- lib/async/app/web_apps/metrics_app.rb
+- lib/async/app/web_apps/metrics_app/serializer.rb
+- lib/async/app/web_apps/metrics_app/store.rb
+- lib/async/app/web_component.rb
 - lib/async/app/web_server.rb
-- lib/async/app/web_server/health_app.rb
-- lib/async/app/web_server/metrics_app.rb
-- lib/async/app/web_server/metrics_app/serializer.rb
-- lib/async/app/web_server/metrics_app/store.rb
-- lib/async/app/web_server/router.rb
 - lib/async/bus.rb
 - lib/async/cache.rb
 - lib/async/channel.rb

data/lib/async/app/web_server/router.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-class Async::App::WebServer::Router
-  extend Async::App::Injector
-
-  def initialize(*apps)
-    @apps = apps
-  end
-
-  def call(request)
-    @apps.each { return Protocol::HTTP::Response[*_1.call(request)] if _1.can_handle?(request) }
-
-    Protocol::HTTP::Response[404, {}, ["Not found"]]
-  end
-end