rails-dev 0.1.0

data/lib/rails_dev/session.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "English"
+require "forwardable"
+
+module RailsDev
+  class Session
+    extend Forwardable
+
+    attr_reader :root, :runtime, :error
+
+    def_delegators :@commands, :env, :run, :capture, :say, :check_for_interrupt
+    def_delegator :@config, :enabled?
+
+    def initialize(root, config, tailscale: false, output: $stdout)
+      @root = root
+      @config = config
+      @tailscale = tailscale
+      @commands = Commands.new(root, output: output, shutdown_timeout: config.shutdown_timeout + 1)
+      @state = State.new(@commands)
+      @hooks = Hooks.new(config, self)
+    end
+
+    def start
+      @commands.with_signals do
+        @state.with_run do |runtime|
+          begin_run(runtime)
+          prepare_environment
+          @hooks.around { start_application }
+        ensure
+          @error = $ERROR_INFO
+          stop
+        end
+      end
+    end
+
+    def url(name = @config.web)
+      @endpoints&.find { |endpoint| endpoint.name == name.to_s }&.url
+    end
+
+    private
+
+    def begin_run(runtime)
+      @runtime = runtime
+      @instance = Instance.new(runtime)
+      @commands.instance = @instance
+      record_run("starting", owner: ProcessTable.new.identity(Process.pid), processes: [],
+                             shutdown_timeout: @config.shutdown_timeout + 1)
+    end
+
+    def record_run(status, **details)
+      @instance.record(name: @config.name, root: root, pid: Process.pid, status: status,
+                       urls: Array(@endpoints).to_h { |endpoint| [endpoint.name, endpoint.url] }, **details)
+    end
+
+    def prepare_environment
+      env.merge!(@config.env)
+      @config.validate_connection_environment(env) if @config.compose_file
+      env.merge!("RAILS_ENV" => "development", "RACK_ENV" => "development", "RAILS_DEV_RUNTIME" => runtime,
+                 "DEV_HOST" => "127.0.0.1", "PIDFILE" => File.join(runtime, "rails.pid"))
+      @foreman = Foreman.new(root, @config)
+      @endpoints = @foreman.endpoints
+      prepare_proxy if @tailscale || @config.https
+    end
+
+    def prepare_proxy
+      @proxy = (@tailscale ? Tailscale : Portless).new(@commands)
+      @proxy.check
+    end
+
+    def start_application
+      @state.synchronize("checkout:#{root}") do
+        check_existing_rails
+        prepare_services
+        start_web
+      end
+      @hooks.call(:after_ready)
+      report_ready
+      supervise
+    ensure
+      @error = $ERROR_INFO
+      @commands.stop
+    end
+
+    def check_existing_rails
+      path = File.join(root, "tmp/pids/server.pid")
+      return unless File.file?(path)
+
+      pid = File.read(path).to_i
+      return unless pid.positive?
+
+      Process.kill(0, pid)
+      raise Error, "Rails is already running for this checkout. Stop it before starting rails-dev."
+    rescue Errno::ESRCH
+      nil
+    end
+
+    def prepare_services
+      if @config.compose_file
+        compose = Compose.new(@config, @commands, @state, runtime)
+        env.merge!(compose.start)
+        @state.synchronize("database:#{compose.lock_key}") { @hooks.call(:before_start) }
+      else
+        @hooks.call(:before_start)
+      end
+    end
+
+    def start_web
+      @state.synchronize("web-ports") do
+        5.times do
+          ports = []
+          @endpoints.each do |endpoint|
+            endpoint.allocate(excluding: ports)
+            ports << endpoint.port
+          end
+          return if launch_web
+
+          @commands.say("A selected port was taken during startup; selecting ports again.")
+          @commands.stop
+        end
+        raise Error, "Ports were repeatedly taken during startup. Try starting again."
+      end
+    end
+
+    def launch_web
+      @deadline = @commands.monotonic_time + @config.startup_timeout
+      @processes = []
+      web = @endpoints.find { |endpoint| endpoint.name == @config.web.to_s }
+      @proxy&.start(@config.name, endpoints: @endpoints, web: web) do |process|
+        @processes << process
+        return false unless await_processes
+      end
+      start_foreman(web)
+      await_processes(check_endpoints: true)
+    end
+
+    def start_foreman(web)
+      @endpoints.each { |endpoint| env.merge!(endpoint.environment) }
+      env.merge!("RAILS_PORT" => web.port.to_s, "RAILS_DEV_URL" => web.url)
+      @application = @commands.start("foreman", @foreman.command, keep_stdin_open: true)
+      @processes << @application
+    end
+
+    def await_processes(check_endpoints: false)
+      loop do
+        @commands.check_for_interrupt
+        return false if startup_failed?
+        return true if ready?(check_endpoints)
+
+        raise Error, startup_timeout(check_endpoints) if @commands.monotonic_time >= @deadline
+
+        sleep 0.05
+      end
+    end
+
+    def startup_failed?
+      failed = @processes.find { |process| !process.running? }
+      return false unless failed
+      return true if failed.startup_conflict? && (failed != @application || ports_taken?)
+
+      process_failed(failed, "during startup")
+    end
+
+    def ports_taken?
+      @endpoints.any? { |endpoint| Ports.available(endpoint.port) != endpoint.port }
+    end
+
+    def process_failed(process, phase)
+      status = process.status.exitstatus || (128 + process.status.termsig)
+      raise Error.new("#{process.name} exited #{phase} (#{process.exit_reason}). See its output above.",
+                      status: status.zero? ? 1 : status)
+    end
+
+    def ready?(check_endpoints)
+      @processes.all?(&:ready?) && (!check_endpoints || @endpoints.map { |endpoint| endpoint.ready?(@deadline) }.all?)
+    end
+
+    def startup_timeout(check_endpoints)
+      pending = @processes.filter_map do |process|
+        "#{process.name}: readiness message not received" unless process.ready?
+      end
+      pending.concat(@endpoints.filter_map(&:readiness_failure)) if check_endpoints
+      ["Startup timed out after #{@config.startup_timeout}s.", *pending,
+       "Check the process output and readiness settings."].join("\n")
+    end
+
+    def report_ready
+      @commands.record_processes
+      record_run("ready")
+      @commands.say("Ready: #{url}")
+      @endpoints.reject { |endpoint| endpoint.name == @config.web.to_s }.each do |endpoint|
+        @commands.say("#{endpoint.name}: #{endpoint.url}")
+      end
+      @commands.say("Press Ctrl+C to stop the app processes.")
+    end
+
+    def supervise
+      loop do
+        @commands.check_for_interrupt
+        failed = @processes.find { |process| !process.running? }
+        return if failed == @application && failed.status.success?
+
+        process_failed(failed, "while running") if failed
+        sleep 0.05
+      end
+    end
+
+    def stop
+      @commands.stop
+    ensure
+      @error ||= $ERROR_INFO
+      @hooks.after_stop(error)
+    end
+  end
+end

data/lib/rails_dev/state.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "tmpdir"
+
+module RailsDev
+  class State
+    attr_reader :directory
+
+    def initialize(commands = nil, base: ENV.fetch("XDG_STATE_HOME", File.join(Dir.home, ".local/state")))
+      @commands = commands
+      @directory = File.join(base, "rails-dev")
+    end
+
+    def with_run
+      FileUtils.mkdir_p(directory, mode: 0o700)
+      Dir.mktmpdir("run-", directory) do |runtime|
+        File.open(File.join(runtime, "owner.lock"), File::RDWR | File::CREAT, 0o600) do |owner|
+          owner.flock(File::LOCK_EX)
+          FileUtils.cp(File.join(__dir__, "vite.mjs"), File.join(runtime, "vite.mjs"))
+          yield runtime
+        end
+      end
+    end
+
+    def runs
+      instances.filter_map(&:snapshot)
+               .sort_by { |run| run.values_at("name", "root", "pid") }
+    end
+
+    def stop(id, root: nil)
+      instance = instances.find { |run| run.id == id }
+      if !instance || (root && instance.snapshot&.fetch("root") != root)
+        raise Error, "Unknown instance: #{id}. See rails-dev list."
+      end
+
+      synchronize("stop:#{id}") { instance.stop }
+    end
+
+    def synchronize(key)
+      FileUtils.mkdir_p(directory, mode: 0o700)
+      path = File.join(directory, "#{Digest::SHA256.hexdigest(key)}.lock")
+      File.open(path, File::RDWR | File::CREAT, 0o600) do |file|
+        until file.flock(File::LOCK_EX | File::LOCK_NB)
+          @commands&.check_for_interrupt
+          sleep 0.05
+        end
+        yield
+      end
+    end
+
+    private
+
+    def instances
+      Dir.glob(File.join(directory, "run-*/instance.json")).map { |path| Instance.new(File.dirname(path)) }
+    end
+  end
+end

data/lib/rails_dev/tailscale.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module RailsDev
+  class Tailscale
+    def initialize(commands)
+      @commands = commands
+    end
+
+    def check
+      status = JSON.parse(@commands.capture("tailscale", "status", "--json"))
+      node = status["Self"] || {}
+      @hostname = node.fetch("DNSName", "").delete_suffix(".")
+      unless status["BackendState"] == "Running" && !@hostname.empty?
+        raise Error, "Connect Tailscale before using --tailscale. Run tailscale status."
+      end
+
+      return if https_enabled?(node)
+
+      raise Error, "Enable HTTPS certificates in your tailnet's DNS settings before using --tailscale."
+    end
+
+    def start(_name, endpoints:, **)
+      endpoints.zip(available_ports(endpoints.size)).each do |endpoint, https|
+        endpoint.url = origin(https)
+        yield @commands.start("tailscale-#{endpoint.name}",
+                              ["tailscale", "serve", "--bg=false", "--https=#{https}", "http://127.0.0.1:#{endpoint.port}"],
+                              ready_message: "Press Ctrl+C to exit.")
+      end
+    end
+
+    private
+
+    def https_enabled?(node)
+      capabilities = Array(node["Capabilities"]) + node.fetch("CapMap", {}).keys
+      capabilities.any? { |capability| capability == "https" || capability.end_with?("/https") }
+    end
+
+    def available_ports(count)
+      config = JSON.parse(@commands.capture("tailscale", "serve", "status", "--json"))
+      used = [config, *config.fetch("Foreground", {}).values].flat_map { |entry| used_ports(entry) }
+      ports = [443].chain(8443..65_535).lazy.reject { |port| used.include?(port) }.take(count).to_a
+      raise Error, "Tailscale needs #{count} available HTTPS ports." unless ports.size == count
+
+      ports
+    end
+
+    def used_ports(config)
+      config.fetch("TCP", {}).keys.map(&:to_i) + config.fetch("AllowFunnel", {}).filter_map do |host, enabled|
+        host.split(":").last.to_i if enabled
+      end
+    end
+
+    def origin(port)
+      URI::HTTPS.build(host: @hostname, port: port).to_s
+    end
+  end
+end

data/lib/rails_dev/version.rb

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

data/lib/rails_dev/vite.mjs

@@ -0,0 +1,31 @@
+import { join } from 'node:path'
+
+export default function railsDev() {
+  const runtime = process.env.RAILS_DEV_RUNTIME
+  const origin = new URL(process.env.RAILS_DEV_VITE_URL)
+
+  return {
+    rails: { devMetaFile: join(runtime, 'rails-vite.json') },
+    plugin: {
+      name: 'rails-dev',
+      apply: 'serve',
+      config: () => ({
+        cacheDir: join(runtime, 'vite-cache'),
+        define: {
+          'import.meta.env.VITE_RAILS_DEV_COOKIE_PREFIX': JSON.stringify(`rails-dev-${process.env.RAILS_PORT}-`),
+        },
+        server: {
+          host: '127.0.0.1',
+          origin: origin.origin,
+          allowedHosts: [origin.hostname],
+          cors: { origin: process.env.RAILS_DEV_URL },
+          ws: {
+            protocol: origin.protocol === 'https:' ? 'wss' : 'ws',
+            host: origin.hostname,
+            clientPort: Number(origin.port || (origin.protocol === 'https:' ? 443 : 80)),
+          },
+        },
+      }),
+    },
+  }
+}

data/lib/rails_dev.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "rails_dev/version"
+
+module RailsDev
+  class Error < StandardError
+    attr_reader :status
+
+    def initialize(message, status: 1)
+      @status = status
+      super(message)
+    end
+  end
+
+  class Interrupted < Error
+    attr_reader :signal
+
+    def initialize(signal)
+      @signal = signal
+      super("Stopped.")
+    end
+  end
+
+  def self.configure
+    raise Error, "Configuration must be loaded by rails-dev." unless @configuration
+
+    yield @configuration
+  end
+
+  def self.load_configuration(configuration, paths)
+    @configuration = configuration
+    paths.each { |path| load path if File.file?(path) }
+  ensure
+    @configuration = nil
+  end
+end
+
+require_relative "rails_dev/configuration"
+require_relative "rails_dev/ports"
+require_relative "rails_dev/endpoint"
+require_relative "rails_dev/foreman"
+require_relative "rails_dev/output"
+require_relative "rails_dev/process_table"
+require_relative "rails_dev/instance"
+require_relative "rails_dev/child"
+require_relative "rails_dev/commands"
+require_relative "rails_dev/state"
+require_relative "rails_dev/service_ports"
+require_relative "rails_dev/compose"
+require_relative "rails_dev/services"
+require_relative "rails_dev/portless"
+require_relative "rails_dev/tailscale"
+require_relative "rails_dev/hooks"
+require_relative "rails_dev/session"
+require_relative "rails_dev/cli"

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: rails-dev
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ali Hamdi Ali Fadel
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: foreman
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.90'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.90'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+email:
+- aliosm1997@gmail.com
+executables:
+- rails-dev
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- docs/reference.md
+- exe/rails-dev
+- lib/rails_dev.rb
+- lib/rails_dev/child.rb
+- lib/rails_dev/cli.rb
+- lib/rails_dev/cli/base.rb
+- lib/rails_dev/cli/main.rb
+- lib/rails_dev/cli/services.rb
+- lib/rails_dev/cli/shell.rb
+- lib/rails_dev/commands.rb
+- lib/rails_dev/compose.rb
+- lib/rails_dev/configuration.rb
+- lib/rails_dev/cookies.rb
+- lib/rails_dev/endpoint.rb
+- lib/rails_dev/foreman.rb
+- lib/rails_dev/hooks.rb
+- lib/rails_dev/instance.rb
+- lib/rails_dev/output.rb
+- lib/rails_dev/portless.mjs
+- lib/rails_dev/portless.rb
+- lib/rails_dev/ports.rb
+- lib/rails_dev/process_table.rb
+- lib/rails_dev/rails_vite.rb
+- lib/rails_dev/railtie.rb
+- lib/rails_dev/service_ports.rb
+- lib/rails_dev/services.rb
+- lib/rails_dev/session.rb
+- lib/rails_dev/state.rb
+- lib/rails_dev/tailscale.rb
+- lib/rails_dev/version.rb
+- lib/rails_dev/vite.mjs
+homepage: https://github.com/milkstrawai/rails-dev
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/milkstrawai/rails-dev
+  source_code_uri: https://github.com/milkstrawai/rails-dev
+  changelog_uri: https://github.com/milkstrawai/rails-dev/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Available ports, HTTPS, and Tailscale for Rails development with Foreman.
+test_files: []