yamine 0.4.0 → 0.6.0

data/lib/yamine/resolver.rb

@@ -9,7 +9,7 @@ module Yamine
     module_function
 
     Result = Struct.new(:app, :tld, :host, :processes, :secrets,
-      :sources, :variant, keyword_init: true)
+      :sources, :variant, :db, :env, keyword_init: true)
 
     def resolve(dir = Dir.pwd, variant: nil, tld: nil, host: nil)
       config = Config.load(dir, variant: variant)
@@ -51,7 +51,9 @@ module Yamine
         processes: processes,
         secrets: config.secrets,
         sources: sources,
-        variant: variant_name
+        variant: variant_name,
+        db: config.data["db"],
+        env: config.env_config
       )
     end
 

data/lib/yamine/runner.rb

@@ -91,22 +91,60 @@ module Yamine
 
     # Run an arbitrary command with PORT + YAMINE_URL. Returns App.
     # register: false spawns without a route (background processes).
+    # Child output goes to log/yamine-<name>.log so `--wait` failure
+    # payloads can tail it (same file the managed path uses).
     def boot_run(name:, hostname:, url:, dir:, command:, port: nil, force: false,
-      rails_dev_host: nil, register: true)
+      rails_dev_host: nil, register: true, database_url: nil, spec: nil)
       port ||= Ports.find_free
-      env = child_env(dir, url: url, port: port, rails_dev_host: rails_dev_host)
-      pid = with_clean_env { spawn(env, *command, chdir: dir) }
+      env = child_env(dir, url: url, port: port, rails_dev_host: rails_dev_host,
+        database_url: database_url)
+      path = log_path(dir, name)
+      pid = with_clean_env { spawn(env, *command, chdir: dir, out: path, err: [:child, :out]) }
       Process.detach(pid)
       target = "127.0.0.1:#{port}"
       if register
-        @store.add_route(hostname, target, Process.pid, kind: "tcp", force: force)
+        spec ||= { "dir" => File.expand_path(dir), "proc" => name }
+        @store.add_route(hostname, target, Process.pid, kind: "tcp",
+          force: force, spec: spec)
         write_backend_pid(hostname, pid)
       end
       App.new(name: name, hostname: hostname, url: url, pid: pid,
         target: target, kind: "tcp", command: command)
     end
 
-    def child_env(dir, url:, port:, rails_dev_host: nil)
+    # Spawn without registering or waiting: the --wait path spins the
+    # whole tree up concurrently, then polls every route until healthy.
+    # Returns the placeholder App (target known before bind). Fate of
+    # the backend is decided by wait, not by spawn.
+    def spawn_http(name:, hostname:, url:, dir:, command:, port:, rails_dev_host: nil,
+      database_url: nil, force: false)
+      env = child_env(dir, url: url, port: port, rails_dev_host: rails_dev_host,
+        database_url: database_url)
+      path = log_path(dir, name)
+      pid = with_clean_env { spawn(env, *command, chdir: dir, out: path, err: [:child, :out]) }
+      Process.detach(pid)
+      App.new(name: name, hostname: hostname, url: url, pid: pid,
+        target: "127.0.0.1:#{port}", kind: "tcp", command: command)
+    end
+
+    # Register an already-spawned backend: route + sidecar, together.
+    def adopt(hostname, app, force: false, spec: nil)
+      @store.add_route(hostname, app.target, Process.pid, kind: app.kind,
+        force: force, spec: spec)
+      write_backend_pid(hostname, app.pid)
+      nil
+    end
+
+    # Still running? A port that accepts is not proof of life, but a
+    # reaped/dead pid is proof of death — that is all wait needs.
+    def spawned?(pid)
+      Process.kill(0, pid)
+      true
+    rescue SystemCallError
+      false
+    end
+
+    def child_env(dir, url:, port:, rails_dev_host: nil, database_url: nil)
       env = { "YAMINE_URL" => url }
       env["PORT"] = port.to_s if port
       env["HOST"] = "127.0.0.1"
@@ -116,6 +154,10 @@ module Yamine
       # proxied hostname so Rails apps boot behind yamine with zero
       # config — this replaces the yamine-rails hosts patch.
       env["RAILS_DEVELOPMENT_HOSTS"] = rails_dev_host if rails_dev_host
+      # Per-worktree database: every process in this worktree shares one
+      # isolated database. Frameworks that honor DATABASE_URL (Rails,
+      # Django, most Node) get isolation for free; others ignore it.
+      env["DATABASE_URL"] = database_url if database_url
       env
     end
 
@@ -212,6 +254,8 @@ module Yamine
       end
     end
 
+    # Log path for a process — public so the --wait failure payload
+    # can tail the right file for the phase that failed.
     def log_path(dir, name)
       path = File.expand_path(File.join(dir, "log", "yamine-#{name}.log"))
       FileUtils.mkdir_p(File.dirname(path))
@@ -229,6 +273,8 @@ module Yamine
       nil
     end
 
+    # Last lines of a log file for failure payloads. Public so the
+    # --wait path can attribute the right tail to the failed phase.
     def log_tail(path, lines: 10)
       return "(no log file)" unless File.file?(path)
 
@@ -237,6 +283,8 @@ module Yamine
       "(unreadable log)"
     end
 
+    private
+
     def stop_pid(pid)
       Process.kill("TERM", pid)
     rescue SystemCallError

data/lib/yamine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yamine
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/yamine.rb

@@ -3,6 +3,7 @@
 require_relative "yamine/version"
 require_relative "yamine/errors"
 require_relative "yamine/agent"
+require_relative "yamine/database"
 require_relative "yamine/sanitize"
 require_relative "yamine/hostname"
 require_relative "yamine/inference"
@@ -20,6 +21,7 @@ require_relative "yamine/proxy"
 require_relative "yamine/proxy_control"
 require_relative "yamine/supervisor"
 require_relative "yamine/runner"
+require_relative "yamine/readiness"
 require_relative "yamine/resolver"
 require_relative "yamine/trust"
 require_relative "yamine/doctor"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yamine
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -91,6 +91,7 @@ files:
 - lib/yamine/cli/system.rb
 - lib/yamine/command.rb
 - lib/yamine/config.rb
+- lib/yamine/database.rb
 - lib/yamine/doctor.rb
 - lib/yamine/errors.rb
 - lib/yamine/framework.rb
@@ -103,6 +104,7 @@ files:
 - lib/yamine/procfile.rb
 - lib/yamine/proxy.rb
 - lib/yamine/proxy_control.rb
+- lib/yamine/readiness.rb
 - lib/yamine/resolver.rb
 - lib/yamine/route_store.rb
 - lib/yamine/runner.rb