svelte-on-rails 23.1.0 → 23.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26d47863e0d0203a1e3eb22d690621ec1710f24b2f6e6808af0bebb159e8c658
-  data.tar.gz: bda202fb4a438357d2d50d74caf97cb1aa9bc8b4408b7adb758dd9b2c3e50476
+  metadata.gz: e1ab30669578fe29fb245c12c41a0b3b25d14771ee678ea57b369fd0fdd3c9bd
+  data.tar.gz: 13abe226046b6277b1c25f088fd0ed1997e4e57d5ae3f758575b55561c5f9372
 SHA512:
-  metadata.gz: 44513e768c709b976ec016a2381a95565b6d933da6a9fe4d81fcc534e2e35ec5a4a6a76cb1fae659b0eb54531468a9e8c940cb3648f8465b120b6eca780b4a37
-  data.tar.gz: d4c83202c7c4137c715fa54cd1ca6f80a7be1be2bc71291a6a6e15b66fd47e36d642752a94e98e26d1b2ce49eb6a890822c8f01bb2568488dbe631bb502eb8fa
+  metadata.gz: 1f0276d33017984819175f07c6203858a98ce736039988cbed471be00f537e5b9827428776c2df29f5594a028cad5e5399c24c0b50e6493cb81e00cf2dd7f657
+  data.tar.gz: 32a6d6da4edbfb741946453ebc4d2cef3de16d0bea30a4749ab394bf0eae647c53eae64d8acd4f649fdb9ffc789e4fc0c2ab85526b382892fc7bc9c75d0d8015

data/lib/svelte_on_rails/cache.rb

@@ -47,7 +47,7 @@ module SvelteOnRails
       end
 
       if entries.empty?
-        puts "No keys found under «#{pattern}»."
+        puts "No keys found under «#{pattern}»." unless silent
         return []
       end
       entries

data/lib/svelte_on_rails/ssr_client.rb

@@ -6,12 +6,15 @@ module SvelteOnRails
 
     include Singleton
 
+    STARTUP_GENERATION_TTL = 30
+
     attr_reader :logfile_path,
                 :logfile_max_lines,
                 :socket_path,
                 :ssr_server_bin_path,
                 :node_bin,
-                :initialized_by
+                :initialized_by,
+                :startup_id
 
     def self.instance(caller: nil)
 
@@ -23,38 +26,38 @@ module SvelteOnRails
 
       @initialized_by = caller
 
-      if startup_leader?
-        File.open(SvelteOnRails::Lib::Utils.ssr_server_logfile, 'w') do |f|
-          f.sync = true
-          f.puts("[#{Time.now.utc.iso8601(3)} ppid:#{Process.ppid} pid:#{Process.pid}]   >>>  Logfile deleted on initializing SsrClient, called by #{caller}  <<<")
-        end
-      end
-
       @socket_namespace = [
         "svelte",
         Rails.application.class.module_parent_name[0..15],
         Rails.env
       ].join("-")
+
+      @startup_leader = startup_leader?
       @socket_path = socket_path_fresh
 
+      if @startup_leader
+        File.open(SvelteOnRails::Lib::Utils.ssr_server_logfile, 'w') do |f|
+          f.sync = true
+          f.puts("[#{Time.now.utc.iso8601(3)} startup_id:#{@startup_id} ppid:#{Process.ppid} pid:#{Process.pid}]   >>>  Logfile deleted on initializing SsrClient, called by #{caller}  <<<")
+        end
+      end
+
       @logfile_path = Rails.root.join("log/svelte-ssr-server-#{Rails.env}.log")
       @logfile_max_lines = build_logfile_max_lines
       @ssr_server = SvelteOnRails::Configuration.instance.configs[:ssr_server]
       @ssr_server_bin_path = SvelteOnRails::Configuration.instance.ssr_server_bin_path
       @started = Time.now
 
-      File.delete(restart_marker_file) if File.exist?(restart_marker_file)
-
-      SvelteOnRails::SsrClientControlChannel.install_control_listener if startup_leader?
+      SvelteOnRails::SsrClientControlChannel.install_control_listener if @startup_leader
 
       if @ssr_server
 
-        start_node_server! if startup_leader?
+        start_node_server! if @startup_leader
 
         at_exit do
-          shutdown(caller: 'at_exit')
-          File.delete(restart_marker_file) if File.exist?(restart_marker_file)
-          FileUtils.remove(flock_file) if File.exist?(flock_file)
+          shutdown(caller: 'at_exit') if @startup_leader
+          @startup_flock&.flock(File::LOCK_UN)
+          @startup_flock&.close
         end
       else
         SvelteOnRails::Lib::Utils.ssr_server_log("SSR Server NOT used => @ssr_server #{@ssr_server}")
@@ -131,7 +134,7 @@ module SvelteOnRails
           :render_failed,
           "Render #{component[:file_basename]}.svelte",
           [
-            raw_response['logs'].to_a.join("\n"),
+            format_node_error_logs(raw_response['logs']),
             "View:\n#{view_path_proc.call}\nComponent:\n#{Rails.root.join(component[:path]).to_s}#{imps}",
           ]
         )
@@ -161,6 +164,7 @@ module SvelteOnRails
       unless File.exist?(socket_path)
         return false
       end
+
       response = ''
       begin
         sock = UNIXSocket.new(socket_path)
@@ -171,6 +175,7 @@ module SvelteOnRails
       rescue => e
         puts "[SOR] Ping Failed: #{e.message}"
       end
+
       if response.match?(/^HTTP\/\d\.\d 200/)
         r = parse_body_json(response)
         unless r['version'].split('.').first.to_i >= 14
@@ -181,11 +186,17 @@ module SvelteOnRails
     end
 
     def start_node_server!(
-      started_by = "rails-boot-#{Rails.env}-#{Process.ppid}",
+      started_by = "rails-boot-#{Rails.env}-#{@startup_id}",
       restart_after_failure: false
     )
 
-      return if ping?
+      if ping?
+        SvelteOnRails::Lib::Utils.ssr_server_log(
+          "SOR start_node_server skipped because SSR server is already running for startup_id #{@startup_id}",
+          ssr_logfile_only: !restart_after_failure
+        )
+        return
+      end
 
       SvelteOnRails::Lib::Utils.ssr_server_log("SOR start_node_server! called", ssr_logfile_only: !restart_after_failure)
 
@@ -203,6 +214,7 @@ module SvelteOnRails
           status: status
         }
       end
+
       SvelteOnRails::Lib::Utils.ssr_server_log("Node Version: #{Configuration.instance.node_version_test}, package version: #{Configuration.instance.npm_package_version_test}")
       SvelteOnRails::Lib::Utils.ssr_server_log("Start running Svelte-SSR-Server... (#{started_by})")
 
@@ -227,30 +239,50 @@ module SvelteOnRails
       SvelteOnRails::Lib::Utils.ssr_server_log("Server responded successfully")
 
       cleanup_leftover_processes
-
-      cleanup_flock_file_later
     end
 
     def restart_my_server(tag = nil)
+      SvelteOnRails::Lib::Utils.ssr_server_log("[ERROR] try to restart the node instances...")
+      FileUtils.mkdir_p(File.dirname(restart_flock_file))
+      restart_flock_existed = File.exist?(restart_flock_file)
+
+      File.open(restart_flock_file, File::RDWR | File::CREAT, 0o644) do |flock|
+        unless flock.flock(File::LOCK_EX | File::LOCK_NB)
+          SvelteOnRails::Lib::Utils.ssr_server_log(
+            "[ERROR] SSR restart already in progress by another worker"
+          )
+          return
+        end
 
-      marker = restart_marker_file
-      if File.exist?(marker) && File.mtime(marker) > 10.seconds.ago
-        SvelteOnRails::Lib::Utils.ssr_server_log("[ERROR] Prevented Server Restart because server was restarted too recently: #{marker}")
-        return
-      end
+        return if ping?
 
-      FileUtils.mkdir_p(marker.dirname)
-      File.open(marker, "a") { |f| f.puts(Time.now.utc.iso8601) }
-      count = File.read(marker).lines.count
+        if restart_flock_existed
+          last_restart_at = File.mtime(restart_flock_file)
+          if last_restart_at > 10.seconds.ago
+            seconds_since_restart = Time.now - last_restart_at
+            SvelteOnRails::Lib::Utils.ssr_server_log(
+              "[ERROR] Prevented Server Restart because server was restarted too recently: #{seconds_since_restart.round(2)}s ago"
+            )
+            return
+          end
+        end
 
-      msg = "Restarting SSR server (#{tag})"
-      Rails.logger.error(msg)
-      SvelteOnRails::Lib::Utils.ssr_server_log("[ERROR] #{msg}")
+        flock.seek(0, IO::SEEK_END)
+        flock.puts(Time.now.utc.iso8601)
+        flock.flush
+        count = File.readlines(restart_flock_file).count
 
-      shutdown(caller: 'restart')
-      begin
-        start_node_server!("#{tag.gsub(' ', '-') + '-' if tag}#{count}", restart_after_failure: true)
-      rescue
+        # RESTART
+
+        msg = "Restarting SSR server (#{tag})"
+        Rails.logger.error(msg)
+        SvelteOnRails::Lib::Utils.ssr_server_log("[ERROR] #{msg}")
+
+        shutdown(caller: 'restart')
+        begin
+          start_node_server!("#{tag.gsub(' ', '-') + '-' if tag}#{count}", restart_after_failure: true)
+        rescue
+        end
       end
     end
 
@@ -259,7 +291,7 @@ module SvelteOnRails
         "ps aux | grep svelte"
       )
       stdout.split("\n").each do |line|
-        if line.include?("#{@socket_namespace}-#{Process.ppid}.sock")
+        if line.include?("#{@socket_namespace}-#{@startup_id}.sock")
           return line.match(/[0-9]+/).to_s.to_i
         end
       end
@@ -282,8 +314,7 @@ module SvelteOnRails
     end
 
     def shutdown(caller: '')
-      SsrClient.instance_variable_set(:@instance, nil)
-      SvelteOnRails::Lib::Utils.ssr_server_log("Shutting down SSR client, ppid: #{Process.ppid} (#{caller})")
+      SvelteOnRails::Lib::Utils.ssr_server_log("Shutting down SSR client, startup_id: #{@startup_id}, ppid: #{Process.ppid} (#{caller})")
       terminate_node_processes(own_processes, label: "own")
       {
         success: true
@@ -296,23 +327,24 @@ module SvelteOnRails
 
     # NODE PROCESS MANAGEMENT
 
-    SsrProcess = Struct.new(:pid, :ppid, :socket_path, keyword_init: true)
+    SsrProcess = Struct.new(:pid, :startup_id, :socket_path, keyword_init: true)
 
     def own_processes
-      scan_processes.select { |p| p.ppid == Process.ppid }
+      scan_processes.select { |p| p.startup_id == @startup_id }
     end
 
     def leftover_processes
-      scan_processes.reject { |p| p.ppid == Process.ppid }
+      scan_processes.reject { |p| p.startup_id == @startup_id }
     end
 
     def leftover_sockets
-      scan_sockets.reject { |s| s[:ppid] == Process.ppid }
+      scan_sockets.reject { |s| s[:startup_id] == @startup_id }
     end
 
     def cleanup_leftover_processes
       terminate_node_processes(leftover_processes, label: "leftover")
       delete_sockets(leftover_sockets.map { |s| s[:path] }, label: "leftover")
+      delete_old_startup_flock_files
     end
 
     # END node process management
@@ -322,49 +354,103 @@ module SvelteOnRails
     def startup_leader?
       return @startup_leader unless @startup_leader.nil?
 
-      FileUtils.mkdir_p(File.dirname(flock_file))
+      FileUtils.mkdir_p(startup_lock_dir)
+
+      if (recent_file = latest_recent_startup_flock_file)
+        @startup_id = startup_id_from_flock_file(recent_file)
+        SvelteOnRails::Lib::Utils.ssr_server_log(
+          "Startup generation reused: startup_id=#{@startup_id}, pid=#{Process.pid}, ppid=#{Process.ppid}",
+          ssr_logfile_only: true
+        )
+        return @startup_leader = false
+      end
+
+      @startup_id = build_startup_id
+      path = startup_flock_file(@startup_id)
 
-      flock = File.open(flock_file, File::RDWR | File::CREAT, 0o644)
+      begin
+        @startup_flock = File.open(path, File::WRONLY | File::CREAT | File::EXCL, 0o644)
+        @startup_flock.flock(File::LOCK_EX | File::LOCK_NB)
+        write_startup_flock_info(@startup_flock)
 
-      if flock.flock(File::LOCK_EX | File::LOCK_NB)
         SvelteOnRails::Lib::Utils.ssr_server_log(
-          "Startup leader process elected: pid=#{Process.pid}, ppid=#{Process.ppid}",
+          "Startup leader process elected: startup_id=#{@startup_id}, pid=#{Process.pid}, ppid=#{Process.ppid}",
           ssr_logfile_only: true
         )
+
         @startup_leader = true
-      else
-        flock.close
+      rescue Errno::EEXIST
+        @startup_flock&.close
+        @startup_flock = nil
+
+        recent_file = latest_recent_startup_flock_file || latest_startup_flock_file
+        @startup_id = startup_id_from_flock_file(recent_file)
 
         SvelteOnRails::Lib::Utils.ssr_server_log(
-          "Startup leader already exists; skipping Node startup in pid=#{Process.pid}, ppid=#{Process.ppid}",
+          "Startup generation already created by another worker: startup_id=#{@startup_id}, pid=#{Process.pid}, ppid=#{Process.ppid}",
           ssr_logfile_only: true
         )
+
         @startup_leader = false
       end
 
       @startup_leader
     end
 
+    def startup_lock_dir
+      Rails.root.join('tmp', 'sockets')
+    end
+
+    def startup_flock_glob
+      startup_lock_dir.join("sor-startup-leader-*.flock")
+    end
+
+    def startup_flock_file(startup_id)
+      startup_lock_dir.join("sor-startup-leader-#{startup_id}.flock")
+    end
+
     def flock_file
-      Rails.root.join('tmp', 'sockets', "sor-startup-leader-#{Process.ppid}.flock")
+      startup_flock_file(@startup_id)
     end
 
-    def cleanup_flock_file_later
-      path = flock_file
+    def restart_flock_file
+      Rails.root.join('tmp', 'sockets', "sor-restart-#{@startup_id}.flock")
+    end
 
-      Thread.new do
-        sleep 3
-        FileUtils.rm_f(path)
-      rescue => e
-        SvelteOnRails::Lib::Utils.ssr_server_log(
-          "Could not remove flock file #{path}: #{e.class}: #{e.message}",
-          ssr_logfile_only: true
-        )
-      end
+    def build_startup_id
+      bucket = Time.now.to_i / STARTUP_GENERATION_TTL * STARTUP_GENERATION_TTL
+      "#{bucket}-#{Process.pid}"
+    end
+
+    def startup_id_from_flock_file(path)
+      basename = File.basename(path.to_s)
+      basename.delete_prefix("sor-startup-leader-").delete_suffix(".flock")
+    end
+
+    def latest_startup_flock_file
+      Dir.glob(startup_flock_glob.to_s).max_by { |path| File.mtime(path) }
+    end
+
+    def latest_recent_startup_flock_file
+      latest = latest_startup_flock_file
+      return unless latest
+
+      age = Time.now - File.mtime(latest)
+      latest if age <= STARTUP_GENERATION_TTL
     end
 
-    def restart_marker_file
-      Rails.root.join("tmp", "ssr_server_last_restart")
+    def write_startup_flock_info(flock)
+      flock.rewind
+      flock.truncate(0)
+      flock.puts({
+                   startup_id: @startup_id,
+                   pid: Process.pid,
+                   ppid: Process.ppid,
+                   rails_root: Rails.root.to_s,
+                   socket_path: socket_path_fresh.to_s,
+                   created_at: Time.now.utc.iso8601(3)
+                 }.to_json)
+      flock.flush
     end
 
     def default_ssr_url
@@ -405,6 +491,7 @@ module SvelteOnRails
 
     def shorten_logfile
       return unless File.exist?(logfile_path)
+
       Thread.new do
         lines = File.readlines(logfile_path, chomp: true)
         unless lines.size <= logfile_max_lines
@@ -434,8 +521,7 @@ module SvelteOnRails
     end
 
     def socket_path_fresh
-      ppid = Process.ppid
-      app_sock = Rails.root.join("tmp/sockets/#{@socket_namespace}-#{ppid}.sock")
+      app_sock = Rails.root.join("tmp/sockets/#{@socket_namespace}-#{@startup_id}.sock")
       if app_sock.to_s.length <= 103
         FileUtils.mkdir_p(File.dirname(app_sock))
         return app_sock
@@ -443,11 +529,23 @@ module SvelteOnRails
 
       # Fallback: socket paths > 103 chars are unreliable on macOS/BSD
       FileUtils.rm_f(app_sock) if File.exist?(app_sock)
-      fallback = Pathname.new("/tmp/#{@socket_namespace}-#{ppid}.sock")
+      fallback = Pathname.new("/tmp/#{@socket_namespace}-#{@startup_id}.sock")
       SvelteOnRails::Lib::Utils.ssr_server_log("sockets longer than 103 chars are risky, fallback to: #{fallback}")
       fallback
     end
 
+    def format_node_error_logs(logs)
+      errors = logs.select { |l| l['level'].downcase.include?('error') }
+      l = errors.present? ? errors : logs
+      l.map do |lg|
+        if lg['level'].present? && lg['msg'].present?
+          "#{lg['level'].upcase}: #{lg['msg']}"
+        else
+          lg.to_s
+        end
+      end.compact.join("\n")
+    end
+
     # NODE PROCESS MANAGEMENT
 
     def terminate_node_processes(processes, label:)
@@ -455,7 +553,7 @@ module SvelteOnRails
 
       processes.group_by(&:socket_path).values.flat_map { |g| g.sort_by(&:pid) }.each do |p|
         Process.kill("SIGINT", p.pid) rescue Errno::ESRCH || Errno::EPERM
-        SvelteOnRails::Lib::Utils.ssr_server_log("  Killed #{label} unix-pid: #{p.pid}, rails-ppid: #{p.ppid}, socket-path: #{p.socket_path}", ssr_logfile_only: true)
+        SvelteOnRails::Lib::Utils.ssr_server_log("  Killed #{label} unix-pid: #{p.pid}, startup_id: #{p.startup_id}, socket-path: #{p.socket_path}", ssr_logfile_only: true)
       end
 
       SvelteOnRails::Lib::Utils.ssr_server_log("Killed #{processes.length} #{label} process#{'es' if processes.length != 1}")
@@ -473,23 +571,36 @@ module SvelteOnRails
       SvelteOnRails::Lib::Utils.ssr_server_log("Deleted #{socket_paths.size} #{label} socket#{'s' if socket_paths.size != 1}")
     end
 
+    def delete_old_startup_flock_files
+      Dir.glob(startup_flock_glob.to_s).each do |path|
+        next if startup_id_from_flock_file(path) == @startup_id
+
+        FileUtils.rm_f(path) if File.exist?(path)
+      rescue => e
+        SvelteOnRails::Lib::Utils.ssr_server_log(
+          "Could not remove old startup flock file #{path}: #{e.class}: #{e.message}",
+          ssr_logfile_only: true
+        )
+      end
+    end
+
     def scan_processes
       stdout, = Open3.capture3("ps aux | grep svelte | grep -v grep")
-      regex = %r{(/\S*#{Regexp.escape(@socket_namespace)}-(\d+)\.sock)\b}
+      regex = %r{(/\S*#{Regexp.escape(@socket_namespace)}-([0-9]+-[0-9]+)\.sock)\b}
 
       stdout.each_line.filter_map do |line|
         m = line.match(regex) or next
         pid = Integer(line.split(/\s+/, 12)[1], exception: false) or next
-        SsrProcess.new(pid: pid, ppid: m[2].to_i, socket_path: m[1])
+        SsrProcess.new(pid: pid, startup_id: m[2], socket_path: m[1])
       end
     end
 
     def scan_sockets
       dirs = [Rails.root.join("tmp/sockets").to_s, "/tmp"]
-      regex = /#{Regexp.escape(@socket_namespace)}-(\d+)\.sock\z/
+      regex = /#{Regexp.escape(@socket_namespace)}-([0-9]+-[0-9]+)\.sock\z/
 
       dirs.flat_map { |d| Dir.glob(File.join(d, "#{@socket_namespace}-*.sock")) }
-          .filter_map { |path| (m = path.match(regex)) && { path: path, ppid: m[1].to_i } }
+          .filter_map { |path| (m = path.match(regex)) && { path: path, startup_id: m[1] } }
     end
 
     # END node process management
@@ -514,6 +625,7 @@ module SvelteOnRails
     # enable communication by rake task for admin purposes
     def self.install_control_listener
       return if @installed
+
       @installed = true
 
       path = socket_path.to_s
@@ -536,6 +648,7 @@ module SvelteOnRails
                            env: Rails.env,
                            uptime: client_instance.uptime,
                            request: request,
+                           startup_id: client_instance.startup_id,
                            socket_path: client_instance.socket_path,
                            initialized_by: client_instance.initialized_by,
                            ping: client_instance.ping?,

data/lib/tasks/ssr_client_tasks.rake

@@ -13,8 +13,6 @@ namespace :svelte_on_rails do
     configs = SvelteOnRails::Configuration.instance
     socket_path = client_status[:socket_path]
 
-    puts client_status.to_s
-
     puts
     puts '=' * @line_width
     puts
@@ -72,7 +70,7 @@ namespace :svelte_on_rails do
         ps_stdout, ps_stderr, ps_status = Open3.capture3(ps_cmd)
         total_kb = ps_stdout.each_line.sum { |line| line.to_i }
 
-        puts "  #{human_bytes(total_kb*1024)} for #{pids.size} node #{'worker'.pluralize(pids.size)}"
+        puts "  #{human_bytes(total_kb*1024)} for #{pids.size} node #{'process'.pluralize(pids.size)}"
 
         redis_entries = SvelteOnRails::Cache.redis_entries(silent: true)
         total_bytes = redis_entries.sum { |e| e[:bytes] }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: svelte-on-rails
 version: !ruby/object:Gem::Version
-  version: 23.1.0
+  version: 23.1.2
 platform: ruby
 authors:
 - Christian Sedlmair