rails_live_reload 0.1.1 → 0.3.0

data/lib/rails_live_reload/web_socket/client_socket.rb

@@ -0,0 +1,153 @@
+require "websocket/driver"
+
+module RailsLiveReload
+  module WebSocket
+    # This class is basically copied from ActionCable
+    # https://github.com/rails/rails/blob/v7.0.3/actioncable/lib/action_cable/connection/client_socket.rb
+    class ClientSocket
+      def self.determine_url(env)
+        scheme = secure_request?(env) ? "wss:" : "ws:"
+        "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
+      end
+
+      def self.secure_request?(env)
+        return true if env["HTTPS"] == "on"
+        return true if env["HTTP_X_FORWARDED_SSL"] == "on"
+        return true if env["HTTP_X_FORWARDED_SCHEME"] == "https"
+        return true if env["HTTP_X_FORWARDED_PROTO"] == "https"
+        return true if env["rack.url_scheme"] == "https"
+
+        false
+      end
+
+      CONNECTING = 0
+      OPEN       = 1
+      CLOSING    = 2
+      CLOSED     = 3
+
+      attr_reader :env, :url
+
+      def initialize(env, event_target, event_loop, protocols)
+        @env          = env
+        @event_target = event_target
+        @event_loop   = event_loop
+
+        @url = ClientSocket.determine_url(@env)
+
+        @driver = @driver_started = nil
+        @close_params = ["", 1006]
+
+        @ready_state = CONNECTING
+
+        @driver = ::WebSocket::Driver.rack(self, protocols: protocols)
+
+        @driver.on(:open)    { |e| open }
+        @driver.on(:message) { |e| receive_message(e.data) }
+        @driver.on(:close)   { |e| begin_close(e.reason, e.code) }
+        @driver.on(:error)   { |e| emit_error(e.message) }
+
+        @stream = RailsLiveReload::WebSocket::Stream.new(@event_loop, self)
+      end
+
+      def start_driver
+        return if @driver.nil? || @driver_started
+        @stream.hijack_rack_socket
+
+        if callback = @env["async.callback"]
+          callback.call([101, {}, @stream])
+        end
+
+        @driver_started = true
+        @driver.start
+      end
+
+      def rack_response
+        start_driver
+        [ -1, {}, [] ]
+      end
+
+      def write(data)
+        @stream.write(data)
+      rescue => e
+        emit_error e.message
+      end
+
+      def transmit(message)
+        return false if @ready_state > OPEN
+        case message
+        when Numeric then @driver.text(message.to_s)
+        when String  then @driver.text(message)
+        when Array   then @driver.binary(message)
+        else false
+        end
+      end
+
+      def close(code = nil, reason = nil)
+        code   ||= 1000
+        reason ||= ""
+
+        unless code == 1000 || (code >= 3000 && code <= 4999)
+          raise ArgumentError, "Failed to execute 'close' on WebSocket: " \
+                               "The code must be either 1000, or between 3000 and 4999. " \
+                               "#{code} is neither."
+        end
+
+        @ready_state = CLOSING unless @ready_state == CLOSED
+        @driver.close(reason, code)
+      end
+
+      def parse(data)
+        @driver.parse(data)
+      end
+
+      def client_gone
+        finalize_close
+      end
+
+      def alive?
+        @ready_state == OPEN
+      end
+
+      def protocol
+        @driver.protocol
+      end
+
+      private
+
+      def open
+        return unless @ready_state == CONNECTING
+        @ready_state = OPEN
+
+        @event_target.on_open
+      end
+
+      def receive_message(data)
+        return unless @ready_state == OPEN
+
+        @event_target.on_message(data)
+      end
+
+      def emit_error(message)
+        return if @ready_state >= CLOSING
+
+        @event_target.on_error(message)
+      end
+
+      def begin_close(reason, code)
+        return if @ready_state == CLOSED
+        @ready_state = CLOSING
+        @close_params = [reason, code]
+
+        @stream.shutdown if @stream
+        finalize_close
+      end
+
+      def finalize_close
+        return if @ready_state == CLOSED
+        @ready_state = CLOSED
+
+        @event_target.on_close(*@close_params)
+      end
+    end
+  end
+end

data/lib/rails_live_reload/web_socket/event_loop.rb

@@ -0,0 +1,131 @@
+require "nio"
+
+module RailsLiveReload
+  module WebSocket
+    # This class is basically copied from ActionCable
+    # https://github.com/rails/rails/blob/v7.0.3/actioncable/lib/action_cable/connection/stream_event_loop.rb
+    class EventLoop
+      def initialize
+        @nio = @executor = @thread = nil
+        @map = {}
+        @stopping = false
+        @todo = Queue.new
+        @spawn_mutex = Mutex.new
+      end
+
+      def timer(interval, &block)
+        Concurrent::TimerTask.new(execution_interval: interval, &block).tap(&:execute)
+      end
+
+      def post(task = nil, &block)
+        task ||= block
+
+        spawn
+        @executor << task
+      end
+
+      def attach(io, stream)
+        @todo << lambda do
+          @map[io] = @nio.register(io, :r)
+          @map[io].value = stream
+        end
+        wakeup
+      end
+
+      def detach(io, stream)
+        @todo << lambda do
+          @nio.deregister io
+          @map.delete io
+          io.close
+        end
+        wakeup
+      end
+
+      def writes_pending(io)
+        @todo << lambda do
+          if monitor = @map[io]
+            monitor.interests = :rw
+          end
+        end
+        wakeup
+      end
+
+      def stop
+        @stopping = true
+        wakeup if @nio
+      end
+
+      private
+
+      def spawn
+        return if @thread && @thread.status
+
+        @spawn_mutex.synchronize do
+          return if @thread && @thread.status
+
+          @nio ||= NIO::Selector.new
+
+          @executor ||= Concurrent::ThreadPoolExecutor.new(
+            min_threads: 1,
+            max_threads: 10,
+            max_queue: 0,
+          )
+
+          @thread = Thread.new { run }
+
+          return true
+        end
+      end
+
+      def wakeup
+        spawn || @nio.wakeup
+      end
+
+      def run
+        loop do
+          if @stopping
+            @nio.close
+            break
+          end
+
+          until @todo.empty?
+            @todo.pop(true).call
+          end
+
+          next unless monitors = @nio.select
+
+          monitors.each do |monitor|
+            io = monitor.io
+            stream = monitor.value
+
+            begin
+              if monitor.writable?
+                if stream.flush_write_buffer
+                  monitor.interests = :r
+                end
+                next unless monitor.readable?
+              end
+
+              incoming = io.read_nonblock(4096, exception: false)
+              case incoming
+              when :wait_readable
+                next
+              when nil
+                stream.close
+              else
+                stream.receive incoming
+              end
+            rescue
+              begin
+                stream.close
+              rescue
+                @nio.deregister io
+                @map.delete io
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_live_reload/web_socket/message_buffer.rb

@@ -0,0 +1,53 @@
+module RailsLiveReload
+  module WebSocket
+    # This class is basically copied from ActionCable
+    # https://github.com/rails/rails/blob/v7.0.3/actioncable/lib/action_cable/connection/message_buffer.rb
+    class MessageBuffer
+      def initialize(connection)
+        @connection = connection
+        @buffered_messages = []
+      end
+
+      def append(message)
+        if valid? message
+          if processing?
+            receive message
+          else
+            buffer message
+          end
+        else
+          raise ArgumentError, "Couldn't handle non-string message: #{message.class}"
+        end
+      end
+
+      def processing?
+        @processing
+      end
+
+      def process!
+        @processing = true
+        receive_buffered_messages
+      end
+
+      private
+
+      attr_reader :connection, :buffered_messages
+
+      def valid?(message)
+        message.is_a?(String)
+      end
+
+      def receive(message)
+        connection.receive message
+      end
+
+      def buffer(message)
+        buffered_messages << message
+      end
+
+      def receive_buffered_messages
+        receive buffered_messages.shift until buffered_messages.empty?
+      end
+    end
+  end
+end

data/lib/rails_live_reload/web_socket/stream.rb

@@ -0,0 +1,109 @@
+module RailsLiveReload
+  module WebSocket
+    # This class is basically copied from ActionCable
+    # https://github.com/rails/rails/blob/v7.0.3/actioncable/lib/action_cable/connection/stream.rb
+    class Stream
+      def initialize(event_loop, socket)
+        @event_loop    = event_loop
+        @socket_object = socket
+        @stream_send   = socket.env["stream.send"]
+
+        @rack_hijack_io = nil
+        @write_lock = Mutex.new
+
+        @write_head = nil
+        @write_buffer = Queue.new
+      end
+
+      def each(&callback)
+        @stream_send ||= callback
+      end
+
+      def close
+        shutdown
+        @socket_object.client_gone
+      end
+
+      def shutdown
+        clean_rack_hijack
+      end
+
+      def write(data)
+        if @stream_send
+          return @stream_send.call(data)
+        end
+
+        if @write_lock.try_lock
+          begin
+            if @write_head.nil? && @write_buffer.empty?
+              written = @rack_hijack_io.write_nonblock(data, exception: false)
+
+              case written
+              when :wait_writable
+              when data.bytesize
+                return data.bytesize
+              else
+                @write_head = data.byteslice(written, data.bytesize)
+                @event_loop.writes_pending @rack_hijack_io
+
+                return data.bytesize
+              end
+            end
+          ensure
+            @write_lock.unlock
+          end
+        end
+
+        @write_buffer << data
+        @event_loop.writes_pending @rack_hijack_io
+
+        data.bytesize
+      rescue EOFError, Errno::ECONNRESET
+        @socket_object.client_gone
+      end
+
+      def flush_write_buffer
+        @write_lock.synchronize do
+          loop do
+            if @write_head.nil?
+              return true if @write_buffer.empty?
+              @write_head = @write_buffer.pop
+            end
+
+            written = @rack_hijack_io.write_nonblock(@write_head, exception: false)
+            case written
+            when :wait_writable
+              return false
+            when @write_head.bytesize
+              @write_head = nil
+            else
+              @write_head = @write_head.byteslice(written, @write_head.bytesize)
+              return false
+            end
+          end
+        end
+      end
+
+      def receive(data)
+        @socket_object.parse(data)
+      end
+
+      def hijack_rack_socket
+        return unless @socket_object.env["rack.hijack"]
+
+        @rack_hijack_io = @socket_object.env["rack.hijack"].call
+        @rack_hijack_io ||= @socket_object.env["rack.hijack_io"]
+
+        @event_loop.attach(@rack_hijack_io, self)
+      end
+
+      private
+
+      def clean_rack_hijack
+        return unless @rack_hijack_io
+        @event_loop.detach(@rack_hijack_io, self)
+        @rack_hijack_io = nil
+      end
+    end
+  end
+end

data/lib/rails_live_reload/web_socket/wrapper.rb

@@ -0,0 +1,27 @@
+require "websocket/driver"
+
+module RailsLiveReload
+  module WebSocket
+    # This class is basically copied from ActionCable
+    # https://github.com/rails/rails/blob/v7.0.3/actioncable/lib/action_cable/connection/web_socket.rb
+    class Wrapper
+      delegate :transmit, :close, :protocol, :rack_response, to: :websocket
+
+      def initialize(env, event_target, event_loop, protocols: RailsLiveReload::INTERNAL[:protocols])
+        @websocket = ::WebSocket::Driver.websocket?(env) ? ClientSocket.new(env, event_target, event_loop, protocols) : nil
+      end
+
+      def possible?
+        websocket
+      end
+
+      def alive?
+        websocket && websocket.alive?
+      end
+
+      private
+
+      attr_reader :websocket
+    end
+  end
+end

data/lib/rails_live_reload.rb

@@ -1,11 +1,10 @@
 require "listen"
 require "rails_live_reload/version"
 require "rails_live_reload/config"
-require "rails_live_reload/client"
 require "rails_live_reload/watcher"
-require "rails_live_reload/rails/middleware/base"
-require "rails_live_reload/rails/middleware/long_polling"
-require "rails_live_reload/rails/middleware/polling"
+require "rails_live_reload/server/connections"
+require "rails_live_reload/server/base"
+require "rails_live_reload/middleware/base"
 require "rails_live_reload/instrument/metrics_collector"
 require "rails_live_reload/thread/current_request"
 require "rails_live_reload/checker"
@@ -16,10 +15,23 @@ module RailsLiveReload
   mattr_accessor :watcher
   @@watcher = {}
 
-  def self.middleware
-    case config.mode
-    when :polling then RailsLiveReload::Rails::Middleware::Polling
-    when :long_polling then RailsLiveReload::Rails::Middleware::LongPolling
-    end
+  INTERNAL = {
+    message_types: {
+      welcome: "welcome",
+      disconnect: "disconnect",
+      ping: "ping",
+    },
+    disconnect_reasons: {
+      invalid_request: "invalid_request",
+      remote: "remote"
+    },
+    socket_events: {
+      reload: 'reload'
+    },
+    protocols: ["rails-live-reload-v1-json"].freeze
+  }
+
+  module_function def server
+    @server ||= RailsLiveReload::Server::Base.new
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_live_reload
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Igor Kasyanchuk
@@ -9,10 +9,10 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-31 00:00:00.000000000 Z
+date: 2022-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -40,41 +40,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: puma
+  name: websocket-driver
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry-nav
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -82,13 +54,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sprockets-rails
+  name: nio4r
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -123,17 +95,23 @@ files:
 - Rakefile
 - lib/rails_live_reload.rb
 - lib/rails_live_reload/checker.rb
-- lib/rails_live_reload/client.rb
 - lib/rails_live_reload/command.rb
 - lib/rails_live_reload/config.rb
 - lib/rails_live_reload/engine.rb
 - lib/rails_live_reload/instrument/metrics_collector.rb
-- lib/rails_live_reload/rails/middleware/base.rb
-- lib/rails_live_reload/rails/middleware/long_polling.rb
-- lib/rails_live_reload/rails/middleware/polling.rb
+- lib/rails_live_reload/javascript/websocket.js
+- lib/rails_live_reload/middleware/base.rb
+- lib/rails_live_reload/server/base.rb
+- lib/rails_live_reload/server/connections.rb
 - lib/rails_live_reload/thread/current_request.rb
 - lib/rails_live_reload/version.rb
 - lib/rails_live_reload/watcher.rb
+- lib/rails_live_reload/web_socket/base.rb
+- lib/rails_live_reload/web_socket/client_socket.rb
+- lib/rails_live_reload/web_socket/event_loop.rb
+- lib/rails_live_reload/web_socket/message_buffer.rb
+- lib/rails_live_reload/web_socket/stream.rb
+- lib/rails_live_reload/web_socket/wrapper.rb
 homepage: https://github.com/railsjazz/rails_live_reload
 licenses:
 - MIT

data/lib/rails_live_reload/client.rb

@@ -1,75 +0,0 @@
-module RailsLiveReload
-  module Client
-
-    def Client.long_polling_js
-      <<~HTML.html_safe
-        <script>
-          (function() {
-            const files = #{CurrentRequest.current.data.to_a.to_json};
-            let retries_count = 0;
-            function poll() {
-              const formData = new FormData();
-              formData.append('dt', #{Time.now.to_i})
-              formData.append('files', JSON.stringify(files))
-
-              fetch(
-                "#{RailsLiveReload.config.url}", 
-                {
-                  method: "post",
-                  headers: { 'Accept': 'application/json', },
-                  body: formData
-                }
-              )
-                .then(response => response.json())
-                .then(data => {
-                  retries_count = 0;
-                  if(data['command'] === 'RELOAD') {
-                    window.location.reload();
-                  } else {
-                    poll();
-                  }
-                }).catch(() => {
-                  retries_count++;
-
-                  if(retries_count < 10) {
-                    setTimeout(poll, 5000)
-                  }
-                })
-            }
-            poll();
-          })();
-        </script>
-      HTML
-    end
-
-    def Client.polling_js
-      <<~HTML.html_safe
-        <script>
-          const files = #{CurrentRequest.current.data.to_a.to_json};
-          const timer = setInterval(
-            () => {
-              const formData = new FormData();
-              formData.append('dt', #{Time.now.to_i})
-              formData.append('files', JSON.stringify(files))
-              fetch(
-                "#{RailsLiveReload.config.url}", 
-                {
-                  method: "post",
-                  headers: { 'Accept': 'application/json', },
-                  body: formData
-                }
-              )
-                .then(response => response.json())
-                .then(data => {
-                  if(data['command'] === 'RELOAD') {
-                    clearInterval(timer);
-                    window.location.reload();
-                  }
-                })
-            }, #{RailsLiveReload.config.polling_interval}
-          )
-        </script>
-      HTML
-    end
-  end
-end