embedding_util 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41974235f403d3694132565fa69ecf07ca338789bd197c34e2563eb7bd38ad06
-  data.tar.gz: c05864e6cda0f5881d44d676ab8b8cb7dc9d7ceee70aff8394a3ee79f8166a69
+  metadata.gz: f388bd90069b46caca18046622511f7fe2bd5c25f2a56a8d02fc01cc673bc682
+  data.tar.gz: 75b484781ae6689e6bf471007257c1e63f4e8aa2485b558e0d41b2f03643749f
 SHA512:
-  metadata.gz: b3500877638960c73de3ebf04ef07441392b86f22108014e4f27e872b95d9ff52cf1850e423443c51bab16ea4c5149a851f619faa53d7f44480f99ae7ebdd759
-  data.tar.gz: e55f3761208466504a9865115d23e0f1ab68bfb146a08ddfcb1c2ae7df4b37a859a80d99aa52139bf6b005fa6ddf4624a96046d58c80f923d183316234042232
+  metadata.gz: 4bd65f54bc228373056843d55aa866d510660361e294bff33b18ec8440f02ae807f4bf5773e6250eb2a5152e53d3656dadef0f624b50f0c1ec32fab689f78367
+  data.tar.gz: 9f51238b20d2aabfda68aace11f276e79cbdeb291468bd888933330869a5717c52f33db2ceb7a46b870a8f138a1b9fcbdbc94e4e5108f529ba7d4aa5ab299e6a

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.1.1] - 2026-06-08
+
+- Fix local server lifecycle cleanup for Ramalama and direct `llama-server`
+- Stop named Ramalama servers after idle shutdown and fall back to Podman/Docker cleanup when needed
+- Ensure direct `llama-server` child processes are terminated on idle shutdown and interruption
+
 ## [0.1.0] - 2026-06-08
 
 - Initial release

data/lib/embedding_util/cli.rb

@@ -87,6 +87,10 @@ module EmbeddingUtil
         host: options[:host],
         port: options[:port]&.to_i
       )
+    rescue Error => e
+      abort e.message
+    rescue Interrupt
+      exit 130
     end
 
     no_commands do

data/lib/embedding_util/runtime_command.rb

@@ -54,11 +54,36 @@ module EmbeddingUtil
       runtime == :llama_server ? "llama-server" : runtime.to_s
     end
 
+    def detached_server?
+      runtime == :ramalama
+    end
+
+    def stop_argv
+      return unless detached_server?
+
+      stop_argvs.first
+    end
+
+    def stop_argvs
+      return [] unless detached_server?
+
+      [
+        ["ramalama", "stop", server_name],
+        ["podman", "stop", "--time", "0", server_name],
+        ["docker", "stop", server_name]
+      ].select { |argv| self.class.command_path(argv.first) }
+    end
+
+    def server_name
+      "embedding-util-#{server_model.name}".tr("_", "-")
+    end
+
     private
 
     def ramalama_argv
       [
         "ramalama", "--runtime=llama.cpp", "serve",
+        "--name", server_name,
         "--host", host,
         "--port", port.to_s,
         "--runtime-args=#{server_model.settings.fetch(:server_flags).join(' ')}",

data/lib/embedding_util/server_manager.rb

@@ -44,18 +44,20 @@ module EmbeddingUtil
       puts "starting #{server_model.name} with #{command.label} on http://#{host}:#{selected_port}"
       puts "shutdown idle: #{shutdown_idle}s" if shutdown_idle&.positive?
 
+      previous_traps = install_interrupt_traps
       Open3.popen2e(*command.argv) do |_stdin, output, wait_thread|
-        write_state(server_model, pid: wait_thread.pid, url: "http://#{host}:#{selected_port}", runtime: command.label, port: selected_port)
-        watchdog = start_watchdog(wait_thread.pid, shutdown_idle) { last_output_at }
-
-        output.each_line do |line|
-          last_output_at = Time.now
-          print line
-        end
-
-        watchdog&.kill
+        url = "http://#{host}:#{selected_port}"
+        write_state(server_model, pid: wait_thread.pid, url: url, runtime: command.label, port: selected_port)
+        last_output_at_mutex = Mutex.new
+        reader = stream_output(output) { last_output_at_mutex.synchronize { last_output_at = Time.now } }
+        wait_for_runtime_serving(command, server_model, url, wait_thread.pid)
+        supervise_runtime(command, wait_thread, shutdown_idle) { last_output_at_mutex.synchronize { last_output_at } }
+      ensure
+        cleanup_runtime(command, wait_thread)
+        reader&.kill
+        reader&.join
         delete_state(server_model)
-        wait_thread.value.exitstatus
+        restore_interrupt_traps(previous_traps)
       end
     end
 
@@ -150,6 +152,96 @@ module EmbeddingUtil
       end
     end
 
+    def stream_output(output)
+      Thread.new do
+        output.each_line do |line|
+          yield
+          print line
+        end
+      end
+    end
+
+    def wait_for_runtime_serving(command, server_model, url, pid)
+      warn "waiting for #{server_model.name} at #{url}" if config.verbose
+      wait_for_serving(server_model, url, pid, check_process: !command.detached_server?)
+      warn "#{server_model.name} is healthy" if config.verbose
+    end
+
+    def supervise_runtime(command, wait_thread, shutdown_idle, &last_output_at)
+      warn "supervising #{command.server_name}" if config.verbose && command.detached_server?
+      return supervise_detached_server(command, shutdown_idle, &last_output_at) if command.detached_server?
+
+      watchdog = start_watchdog(wait_thread.pid, shutdown_idle, &last_output_at)
+      wait_thread.value.exitstatus
+    ensure
+      watchdog&.kill
+    end
+
+    def wait_for_serving(server_model, url, pid, check_process: true)
+      deadline = Time.now + config.startup_timeout
+      loop do
+        return if healthy_url?(url)
+        raise UnsupportedProviderError, "#{server_model.name} server process exited before becoming healthy" if check_process && !process_running?(pid)
+        raise UnsupportedProviderError, "timed out after #{config.startup_timeout}s waiting for #{server_model.name} to become healthy" if Time.now >= deadline
+
+        sleep 0.25
+      end
+    end
+
+    def supervise_detached_server(command, shutdown_idle)
+      loop do
+        if idle_expired?(shutdown_idle, yield)
+          warn "stopping #{command.server_name} after #{shutdown_idle}s idle" if config.verbose
+          stop_detached_server(command)
+          return 0
+        end
+
+        sleep [shutdown_idle.to_f / 5.0, 1].max
+      end
+    rescue Interrupt
+      stop_detached_server(command)
+      130
+    end
+
+    def idle_expired?(shutdown_idle, last_output_at)
+      shutdown_idle&.positive? && Time.now - last_output_at >= shutdown_idle
+    end
+
+    def stop_detached_server(command)
+      command.stop_argvs.any? do |stop_argv|
+        system(*stop_argv, out: File::NULL, err: File::NULL)
+      end
+    end
+
+    def cleanup_runtime(command, wait_thread)
+      return unless command
+
+      if command.detached_server?
+        stop_detached_server(command)
+      else
+        terminate_runtime_process(command, wait_thread&.pid)
+      end
+    end
+
+    def terminate_runtime_process(command, pid)
+      return if command.detached_server? || !pid || pid == Process.pid || !process_running?(pid)
+
+      terminate_idle_process(pid)
+    rescue Errno::ESRCH
+      nil
+    end
+
+    def install_interrupt_traps
+      %w[INT TERM].to_h do |signal|
+        previous = Signal.trap(signal) { Thread.main.raise Interrupt }
+        [signal, previous]
+      end
+    end
+
+    def restore_interrupt_traps(previous_traps)
+      previous_traps&.each { |signal, handler| Signal.trap(signal, handler) }
+    end
+
     def terminate_idle_process(pid)
       Process.kill("TERM", pid)
       sleep 5

data/lib/embedding_util/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: embedding_util
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - hmdne