rails-dev 0.1.0

data/lib/rails_dev/instance.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RailsDev
+  class Instance
+    def initialize(directory)
+      @directory = directory
+      @path = File.join(directory, "instance.json")
+    end
+
+    def id
+      File.basename(@directory)
+    end
+
+    def record(**details)
+      data = File.file?(@path) ? read : {}
+      File.write("#{@path}.tmp", JSON.generate(data.merge(details.transform_keys(&:to_s))), perm: 0o600)
+      File.rename("#{@path}.tmp", @path)
+    end
+
+    def record_processes(groups)
+      record(processes: ProcessTable.new.members(groups))
+    end
+
+    def snapshot
+      File.open(File.join(@directory, "owner.lock")) do |owner|
+        data = read.merge("id" => id)
+        data["status"] = interrupted_status(data) if owner.flock(File::LOCK_EX | File::LOCK_NB)
+        data
+      end
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def stop
+      File.open(File.join(@directory, "owner.lock")) do |owner|
+        stop_owner(owner)
+        recover if File.file?(@path)
+      end
+    rescue Errno::ENOENT
+      nil
+    end
+
+    private
+
+    def read
+      JSON.parse(File.read(@path))
+    end
+
+    def interrupted_status(data)
+      records = data["processes"]
+      return "interrupted" unless records
+
+      table = ProcessTable.new
+      return "orphaned" if records.any? { |identity| table.include?(identity) }
+
+      table.members(process_groups(records)).empty? ? "stale" : "interrupted"
+    end
+
+    def process_groups(records)
+      records.map { |identity| identity[1] }.uniq
+    end
+
+    def stop_owner(owner)
+      return if owner.flock(File::LOCK_EX | File::LOCK_NB)
+
+      timeout = read.fetch("shutdown_timeout", 5)
+      signal_owner(owner, "TERM")
+      return if wait(timeout + 2) { owner.flock(File::LOCK_EX | File::LOCK_NB) }
+
+      signal_owner(owner, "KILL")
+      return if wait(2) { owner.flock(File::LOCK_EX | File::LOCK_NB) }
+
+      raise Error, "Instance #{id} is still stopping; retry with rails-dev stop #{id}."
+    end
+
+    def signal_owner(owner, signal)
+      data = read
+      identity = data["owner"]
+      if ProcessTable.new.include?(identity)
+        signal(signal, identity.first)
+      elsif !owner.flock(File::LOCK_EX | File::LOCK_NB)
+        raise Error, recovery_error("Cannot verify the launcher for #{id} (PID #{data.fetch("pid")}). " \
+                                    "Stop it from its original terminal.")
+      end
+    end
+
+    def recovery_error(message)
+      "#{message}\nInspect #{@path} and verify process ownership before manual cleanup."
+    end
+
+    def recover
+      data = read
+      @records = data.fetch("processes") do
+        raise Error, recovery_error("Cannot recover #{id}: process ownership was not recorded.")
+      end
+      @records = verified_members
+      record(processes: @records)
+      stop_groups(data.fetch("shutdown_timeout", 5))
+      FileUtils.remove_entry(@directory)
+    end
+
+    def verified_members
+      table = ProcessTable.new
+      members = table.members(process_groups(@records))
+      verified = process_groups(@records.select { |identity| table.include?(identity) })
+      unverified = process_groups(members) - verified
+      unless unverified.empty?
+        raise Error, recovery_error("Cannot verify process groups #{unverified.join(", ")} for #{id}. " \
+                                    "Recovery record kept.")
+      end
+
+      members
+    end
+
+    def stop_groups(timeout)
+      signal_groups("TERM")
+      return if wait(timeout) { verified_members.empty? }
+
+      signal_groups("KILL")
+      return if wait(2) { verified_members.empty? }
+
+      raise Error, "Instance #{id} is still stopping; retry with rails-dev stop #{id}."
+    end
+
+    def signal_groups(value)
+      process_groups(verified_members).each { |group| signal(value, -group) }
+    end
+
+    def signal(value, pid)
+      Process.kill(value, pid)
+    rescue Errno::ESRCH
+      nil
+    end
+
+    def wait(timeout)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      loop do
+        return true if yield
+        return false if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+        sleep 0.05
+      end
+    end
+  end
+end

data/lib/rails_dev/output.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module RailsDev
+  class Output < SimpleDelegator
+    def write(*)
+      super
+    rescue Errno::EIO, Errno::EPIPE
+      0
+    end
+
+    def puts(*)
+      super
+    rescue Errno::EIO, Errno::EPIPE
+      nil
+    end
+
+    def print(*)
+      super
+    rescue Errno::EIO, Errno::EPIPE
+      nil
+    end
+
+    def flush
+      super
+    rescue Errno::EIO, Errno::EPIPE
+      nil
+    end
+  end
+end

data/lib/rails_dev/portless.mjs

@@ -0,0 +1,28 @@
+import { pathToFileURL } from 'node:url'
+
+const [modulePath, directory, routeJSON] = process.argv.slice(2)
+const { RouteStore } = await import(pathToFileURL(modulePath).href)
+const store = new RouteStore(directory)
+const routes = Object.entries(JSON.parse(routeJSON))
+
+function stop() {
+  cleanup()
+  process.exit(0)
+}
+
+function cleanup() {
+  for (const [hostname] of routes) store.removeRoute(hostname, process.pid)
+}
+
+process.on('SIGTERM', stop)
+process.on('SIGINT', stop)
+
+try {
+  for (const [hostname, port] of routes) store.addRoute(hostname, port, process.pid)
+  setInterval(() => {}, 60_000)
+  console.log('HTTPS routes registered')
+} catch (error) {
+  cleanup()
+  console.error(error.message)
+  process.exitCode = 1
+}

data/lib/rails_dev/portless.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module RailsDev
+  class Portless
+    VERSION = "0.15.6"
+
+    attr_reader :url
+
+    def initialize(commands)
+      @commands = commands
+      data = commands.env.fetch("XDG_DATA_HOME", File.join(Dir.home, ".local/share"))
+      @prefix = File.join(data, "rails-dev/portless", VERSION)
+      @package = File.join(@prefix, "lib/node_modules/portless")
+      @directory = File.expand_path(commands.env.fetch("PORTLESS_STATE_DIR", File.join(Dir.home, ".portless")))
+      commands.env["PORTLESS_STATE_DIR"] = @directory
+    end
+
+    def setup(port: 443)
+      raise Error, "Proxy port must be between 1 and 65535." unless (1..65_535).cover?(port)
+
+      @commands.with_signals { install }
+      @commands.env.merge!("PORTLESS_LAN" => "0", "PORTLESS_WILDCARD" => "0")
+      @commands.replace([*cli, "service", "install", "--https", "--port", port.to_s, "--tld", "localhost"])
+    end
+
+    def install
+      version = @commands.capture("node", "--version").delete_prefix("v").to_i
+      raise Error, "Portless requires Node.js 24 or newer." if version < 24
+      return if installed?
+
+      @commands.run("npm", "install", "--global", "--prefix", @prefix,
+                    "--ignore-scripts", "--no-audit", "--no-fund", "portless@#{VERSION}")
+    end
+
+    def doctor
+      require_installation
+      @commands.replace([*cli, "doctor"])
+    end
+
+    def check
+      require_installation
+      @url = URI(@commands.capture(*cli, "get", "rails-dev", "--no-worktree").strip)
+      unless url.is_a?(URI::HTTPS) && url.host == "rails-dev.localhost"
+        raise Error, "The shared Portless proxy must use HTTPS and .localhost. Run rails-dev setup."
+      end
+
+      verify_proxy
+    end
+
+    def start(name, endpoints:, web:)
+      routes = endpoints.to_h do |endpoint|
+        host = hostname(name, endpoint, web)
+        endpoint.url = origin(host)
+        [host, endpoint.port]
+      end
+      @commands.env["NODE_EXTRA_CA_CERTS"] ||= File.join(@directory, "ca.pem")
+      yield @commands.start("https", ["node", File.join(__dir__, "portless.mjs"),
+                                      File.join(@package, "dist/index.js"), @directory, JSON.generate(routes)],
+                            ready_message: "HTTPS routes registered")
+    end
+
+    private
+
+    def hostname(name, endpoint, web)
+      label = "#{name}-#{web.port}"
+      label += "-#{endpoint.name.downcase.tr("_", "-")}" unless endpoint == web
+      "#{label}.localhost"
+    end
+
+    def cli
+      ["node", File.join(@package, "dist/cli.js")]
+    end
+
+    def installed?
+      path = File.join(@package, "package.json")
+      File.file?(path) && JSON.parse(File.read(path))["version"] == VERSION
+    end
+
+    def require_installation
+      return if installed?
+
+      raise Error, "Portless #{VERSION} is not installed for rails-dev. Run rails-dev setup once on this machine."
+    end
+
+    def verify_proxy
+      return if proxy_connection.get("/")["X-Portless"] == "1"
+
+      raise Error, "The HTTPS listener is not Portless. Run rails-dev doctor."
+    rescue SystemCallError, IOError, OpenSSL::SSL::SSLError, Net::OpenTimeout, Net::ReadTimeout => error
+      raise Error, "Cannot reach the HTTPS proxy: #{error.message}. Run rails-dev setup or rails-dev doctor."
+    end
+
+    def proxy_connection
+      http = Net::HTTP.new(url.host, url.port, nil)
+      http.ipaddr = "127.0.0.1"
+      http.use_ssl = true
+      http.ca_file = File.join(@directory, "ca.pem")
+      http.open_timeout = http.read_timeout = 3
+      http
+    end
+
+    def origin(host)
+      uri = url.dup
+      uri.host = host
+      uri.to_s
+    end
+  end
+end

data/lib/rails_dev/ports.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module RailsDev
+  module Ports
+    def self.available(first, excluding: [])
+      (first..65_535).each do |port|
+        next if excluding.include?(port)
+
+        begin
+          TCPServer.open("127.0.0.1", port) { return port }
+        rescue Errno::EADDRINUSE, Errno::EACCES
+          next
+        end
+      end
+      raise Error, "No available local port at or above #{first}."
+    end
+  end
+end

data/lib/rails_dev/process_table.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RailsDev
+  class ProcessTable
+    def initialize
+      output, status = Open3.capture2({ "LC_ALL" => "C", "TZ" => "UTC0" },
+                                      "ps", "-A", "-o", "pid=,pgid=,stat=,lstart=")
+      raise Error, "Cannot inspect running processes." unless status.success?
+
+      @entries = output.lines.filter_map do |line|
+        pid, group, state, started = line.strip.split(/\s+/, 4)
+        [pid.to_i, [pid.to_i, group.to_i, started]] unless state.start_with?("Z", "X")
+      end.to_h
+    rescue Errno::ENOENT
+      raise Error, "Cannot inspect running processes: ps is unavailable."
+    end
+
+    def identity(pid)
+      @entries[pid]
+    end
+
+    def include?(identity)
+      identity && self.identity(identity.first) == identity
+    end
+
+    def members(groups)
+      @entries.values.select { |entry| groups.include?(entry[1]) }
+    end
+  end
+end

data/lib/rails_dev/rails_vite.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module RailsDev
+  class RailsViteRailtie < Rails::Railtie
+    initializer "rails_dev.vite", before: :load_config_initializers do
+      next unless Rails.env.development? && ENV.fetch("RAILS_DEV_RUNTIME", nil) && ENV["RAILS_DEV_VITE_URL"]
+
+      RailsVite.config.dev_meta_path = Pathname.new(ENV.fetch("RAILS_DEV_RUNTIME")).join("rails-vite.json")
+      RailsVite.config.auto_build = false
+    end
+  end
+end

data/lib/rails_dev/railtie.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+require "uri"
+require_relative "cookies"
+
+module RailsDev
+  class Railtie < Rails::Railtie
+    initializer "rails_dev.configure", before: :load_config_initializers do |app|
+      next unless Rails.env.development? && ENV.key?("RAILS_DEV_RUNTIME") && ENV.key?("RAILS_DEV_URL")
+
+      app.middleware.insert_before ActionDispatch::Cookies, Cookies, prefix: "rails-dev-#{ENV.fetch("RAILS_PORT")}-"
+
+      origin = URI(ENV.fetch("RAILS_DEV_URL"))
+      url_options = { host: origin.host, port: origin.port, protocol: origin.scheme }
+      app.config.hosts << origin.host
+      app.config.action_mailer.default_url_options = url_options
+      app.routes.default_url_options.merge!(url_options)
+    end
+  end
+end

data/lib/rails_dev/service_ports.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RailsDev
+  class ServicePorts
+    attr_reader :ports
+
+    def initialize(services, config)
+      @config = config
+      @ports = services.to_h { |name, service| [name, service_ports(name, service)] }
+      validate_connections
+    end
+
+    def override
+      entries = ports.map do |name, mappings|
+        "  #{name.to_json}:\n    ports: !override #{mappings.to_json}\n"
+      end
+      entries += @config.exclude_services.map { |name| "  #{name.to_json}: !reset null\n" }
+      "services:\n#{entries.join}"
+    end
+
+    def environment(endpoints)
+      @config.connections.to_h do |variable, mapping|
+        endpoint = endpoints.fetch([mapping[:service], mapping[:port], mapping[:protocol]])
+        value = mapping.fetch(:value).gsub("%{host}", endpoint.fetch(:host)).gsub("%{port}", endpoint.fetch(:port))
+        [variable, value]
+      end
+    end
+
+    private
+
+    def service_ports(name, service)
+      validate_service(name, service)
+      declared = declared_ports(service)
+      additional = @config.publish_ports.fetch(name, []).flat_map do |port|
+        target, protocol = port.to_s.split("/", 2)
+        expand(target, protocol || "tcp")
+      end
+      (declared + additional).uniq
+    end
+
+    def validate_service(name, service)
+      if service["network_mode"] == "host" || service.fetch("scale", 1) != 1 ||
+         service.dig("deploy", "replicas").to_i > 1
+        raise Error, "#{name}: host networking and multiple replicas are not supported."
+      end
+    end
+
+    def declared_ports(service)
+      service.fetch("ports", []).flat_map do |port|
+        expand(port.fetch("target"), port.fetch("protocol", "tcp"))
+      end
+    end
+
+    def expand(target, protocol)
+      match = /\A(\d+)(?:-(\d+))?\z/.match(target.to_s)
+      raise Error, "Invalid container port: #{target}/#{protocol}." unless match && %w[tcp udp].include?(protocol)
+
+      port_range(match).map { |port| { "target" => port, "host_ip" => "127.0.0.1", "protocol" => protocol } }
+    end
+
+    def port_range(match)
+      first = match[1].to_i
+      last = (match[2] || match[1]).to_i
+      unless first.positive? && last >= first && last <= 65_535
+        raise Error, "Invalid container port range: #{match[0]}."
+      end
+
+      first..last
+    end
+
+    def validate_connections
+      validate_publications
+      @config.connections.each do |variable, mapping|
+        port = ports.fetch(mapping.fetch(:service), [])
+        next if port.any? { |entry| entry["target"] == mapping[:port] && entry["protocol"] == mapping[:protocol] }
+
+        raise Error, "#{variable}: mapped port is not published by an active service. " \
+                     "Use Compose ports or publish_ports."
+      end
+    end
+
+    def validate_publications
+      @config.publish_ports.each_key do |name|
+        raise Error, "Cannot publish ports for inactive or unknown service #{name.inspect}." unless ports.key?(name)
+      end
+    end
+  end
+end

data/lib/rails_dev/services.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module RailsDev
+  class Services
+    def initialize(root, config, output: $stdout)
+      @config = config
+      @commands = Commands.new(root, output: output)
+      @state = State.new(@commands)
+    end
+
+    def run(action, argv = [])
+      @commands.with_signals do
+        @commands.env.merge!(@config.env)
+        manage(action) if @config.compose_file
+        raise Error, "Set config.compose_file to manage Compose services." if !@config.compose_file && action != "exec"
+      end
+      @commands.replace(argv) if action == "exec"
+    end
+
+    private
+
+    def manage(action)
+      @config.validate_connection_environment(@commands.env) unless action == "stop"
+      FileUtils.mkdir_p(@state.directory, mode: 0o700)
+      Dir.mktmpdir("services-", @state.directory) do |runtime|
+        compose = Compose.new(@config, @commands, @state, runtime)
+        if action == "stop"
+          compose.stop
+        else
+          @commands.env.merge!(compose.start)
+        end
+      end
+    end
+  end
+end