lowloop 0.8.3 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bcc48c80995bdc907a7340bfd70b3b643cbdba6009a0860653789cce9dd309d
-  data.tar.gz: 75c29bd962bb6907de4c9937b065febfb3f5e0de5aa0a8b9e65dbaa1da79f303
+  metadata.gz: 86ba32309fe8da07372146ac9ebda8cfb628eb5ed6028585f6372b35d88c7c01
+  data.tar.gz: 703acb9eda25c293dc701b1f0c255db0a2a0c4592b000637c2af2708b2bf8f55
 SHA512:
-  metadata.gz: f71e8ed10a287dfad978f62c1536267e294d43f2256df10c1e35bfacf592d59276acd9d5d20400a6cc5e6be0926ba62fc849c4335f19f4b4d5f44d797134fc93
-  data.tar.gz: 8dd496d5e6c21032b5b1ecad04823918efa69c63a4a5ac0cef974d3eafb13350b5993eced6ec93575486e426e76cefaaae371397e5f4a46feae75a3d824b648d
+  metadata.gz: 26a1b66b508158426fa93749757976b0c24e4b1143a1a9b2630f7074ead1c17302a82efe7e0e82846f76afc7d2bb680e733bd6cc8da1d34e35603549b2c8068e
+  data.tar.gz: 64965b0ded7fe458cc2da52cd6c89011a26a9c87c1d122b3e618ed8c67ce761df98fe26f2afcb09cb5b7ce53cf474b3475a2c74117c583b255909078667b3498

data/lib/connections/connection_manager.rb

@@ -4,14 +4,17 @@ require 'io/wait'
 
 require_relative 'request_parser'
 require_relative '../responses/response_builder'
+require_relative '../responses/response_factory'
 
 module Low
   class ConnectionManager
     DEFAULT_KEEP_ALIVE_TIMEOUT = 30
     DEFAULT_REQUEST_TIMEOUT = 10
 
-    def initialize(config:)
+    # on_error is called with an error raised while responding to a request, before responding with a 500.
+    def initialize(config:, on_error: nil)
       @config = config
+      @on_error = on_error
     end
 
     def handle_connection(socket:)
@@ -35,8 +38,7 @@ module Low
         version ||= request.version
         keep_alive = keep_alive?(request)
 
-        response_event = Events::RequestEvent.take(request:)
-        response = response_event.response
+        response = respond_to(request:)
 
         ResponseBuilder.respond(config:, socket:, response:, keep_alive:)
       end
@@ -65,5 +67,13 @@ module Low
     private
 
     attr_reader :config
+
+    # An error in the application responds with a 500 and keeps the connection, rather than closing it without a response.
+    def respond_to(request:)
+      Events::RequestEvent.take(request:).response
+    rescue StandardError => e
+      @on_error&.call(e)
+      ResponseFactory.error(error: e, debug: config.debug_mode)
+    end
   end
 end

data/lib/connections/request_parser.rb

@@ -66,10 +66,11 @@ module Low
       def parse_body(stream: IO::Stream::Generic, method: String, headers: ::Protocol::HTTP::Headers)
         return nil unless %w[POST PUT PATCH].include?(method)
 
-        content_length = headers['content-length']&.first&.to_i
-        return nil unless content_length&.positive?
+        # A single value header like content-length is a String.
+        content_length = headers['content-length'].to_i
+        return nil unless content_length.positive?
 
-        stream.read(content_length)
+        ::Protocol::HTTP::Body::Buffered.wrap(stream.read(content_length))
       end
     end
   end

data/lib/lowloop.rb

@@ -19,7 +19,7 @@ class LowLoop
 
   def initialize(config:, router: nil, renderer: nil, show_output: true)
     @config = config
-    @connection_manager = Low::ConnectionManager.new(config:)
+    @connection_manager = Low::ConnectionManager.new(config:, on_error: method(:render_error))
     @frame = LowFrame.new(renderer: (renderer if config.matrix_mode), fps: 10, show_output:)
 
     Low::Events::RequestEvent.define do |observers|
@@ -37,6 +37,7 @@ class LowLoop
 
       loop do
         socket = server.accept
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
 
         task.async do
           @connection_manager.handle_connection(socket:)
@@ -52,7 +53,7 @@ class LowLoop
   # Fallback mode for when there's no dependencies and you want to know that the server is still working.
   def mirror(event:)
     request = event.request
-    response = tories::ResponseFactory.html(body: "Thank you for visiting #{request.path} with body: '#{request.body}'")
+    response = Low::ResponseFactory.html(body: "Thank you for visiting #{request.path} with body: '#{request.body&.join}'")
     Low::Events::ResponseEvent.new(response:)
   end
 
@@ -87,13 +88,26 @@ class LowLoop
     puts Paint[error.message, :red]
     puts ''
 
-    return unless @config.debug_mode
-
-    Fiber.blocking do
-      puts Paint[error.backtrace.join("\n"), :blue]
+    if @config.debug_mode
+      puts Paint[error.backtrace&.join("\n"), :blue]
       puts ''
-      puts 'Press ENTER to continue...'
-      gets
+    end
+
+    pause_frame if @frame.renderer
+  end
+
+  # Renderers replaces the screen every frame, so pause it to keep the error on screen until ENTER is pressed.
+  def pause_frame
+    return if @frame.paused?
+
+    @frame.pause
+    puts 'Press ENTER to continue...'
+
+    # Non-blockinly wait for IO. The main event loop keeps responding to requests while the frame is paused.
+    Async do
+      $stdin.gets
+    ensure
+      @frame.resume
     end
   end
 end

data/lib/responses/response_builder.rb

@@ -10,44 +10,48 @@ module Low
         if file_body
           content_length = response.body.file.size
         else
-          body_data = response.body.read || ''
+          # A response can have no body, like a node returning "Status[201]", and "join" reads every chunk of a body.
+          body_data = response.body&.join || ''
           content_length = body_data.bytesize
         end
 
-        write_status_line(socket, response)
-        write_host_header(socket, config)
-        write_response_headers(socket, response)
-        write_final_headers(socket, content_length, keep_alive)
+        # Build the whole head in memory then write once, as every socket write is a syscall.
+        head = +''
+        write_status_line(head, response)
+        write_host_header(head, config)
+        write_response_headers(head, response)
+        write_final_headers(head, content_length, keep_alive)
 
         if file_body
+          socket.write(head)
           IO.copy_stream(response.body.file, socket)
         else
-          socket.write(body_data)
+          socket.write(head << body_data)
         end
       end
 
       private
 
-      def write_status_line(socket, response)
-        socket.puts "#{response.version} #{response.status}\r\n"
+      def write_status_line(head, response)
+        head << "#{response.version} #{response.status}\r\n"
       end
 
-      def write_host_header(socket, config)
-        socket.puts config.port.nil? ? "Host: #{config.host}\r\n" : "Host: #{config.host}:#{config.port}\r\n"
+      def write_host_header(head, config)
+        head << (config.port.nil? ? "Host: #{config.host}\r\n" : "Host: #{config.host}:#{config.port}\r\n")
       end
 
-      def write_response_headers(socket, response)
+      def write_response_headers(head, response)
         response.headers.fields.each do |key, value|
           next if %w[content-length connection].include?(key.to_s.downcase)
 
-          socket.puts "#{key}: #{value}\r\n"
+          head << "#{key}: #{value}\r\n"
         end
       end
 
-      def write_final_headers(socket, content_length, keep_alive)
-        socket.puts "Content-Length: #{content_length}\r\n"
-        socket.puts "Connection: #{keep_alive ? 'keep-alive' : 'close'}\r\n"
-        socket.puts "\r\n"
+      def write_final_headers(head, content_length, keep_alive)
+        head << "Content-Length: #{content_length}\r\n"
+        head << "Connection: #{keep_alive ? 'keep-alive' : 'close'}\r\n"
+        head << "\r\n"
       end
     end
   end

data/lib/responses/response_factory.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'cgi'
 require 'protocol/http'
 require 'protocol/http/body/file'
 
@@ -9,7 +10,6 @@ module Low
       def html(body:)
         headers = Protocol::HTTP::Headers.new([['content-type', 'text/html']])
         body = Protocol::HTTP::Body::Buffered.wrap(body.strip)
-
         Protocol::HTTP::Response.new('HTTP/1.1', 200, headers, body)
       end
 
@@ -17,13 +17,24 @@ module Low
         headers = Protocol::HTTP::Headers.new([['content-type', content_type]])
         file = File.open(path, 'rb')
         body = Protocol::HTTP::Body::File.new(file)
-
         Protocol::HTTP::Response.new('HTTP/1.1', 200, headers, body)
       end
 
-      def status(code:)
+      # Shows the error and where it happened in debug mode (or show a 500 status).
+      def error(error:, debug: false)
         headers = Protocol::HTTP::Headers.new([['content-type', 'text/html']])
+        trace = CGI.escapeHTML("#{error.class}: #{error.message}\n\n#{error.backtrace&.join("\n")}") if debug
+
+        html = <<~HTML.strip
+          <h1>500 Internal Server Error</h1>
+          #{"<pre>#{trace}</pre>" if debug}
+        HTML
 
+        Protocol::HTTP::Response.new('HTTP/1.1', 500, headers, Protocol::HTTP::Body::Buffered.wrap(html))
+      end
+
+      def status(code:)
+        headers = Protocol::HTTP::Headers.new([['content-type', 'text/html']])
         Protocol::HTTP::Response.new('HTTP/1.1', code, headers, nil)
       end
     end

data/lib/support/low_frame.rb

@@ -20,12 +20,26 @@ class LowFrame
   end
 
   def render
+    return if @paused
     return unless @last_frame.nil? || (current_timestamp - @last_frame) >= @frame_time
 
     @last_frame = current_timestamp
     @renderer.render(screen_size: @screen_size)
   end
 
+  # Stops rendering so that output isn't replaced by the next frame.
+  def pause
+    @paused = true
+  end
+
+  def resume
+    @paused = false
+  end
+
+  def paused?
+    @paused == true
+  end
+
   def setup
     print "\e[?25l" # Hide cursor.
     system 'clear'

data/lib/version.rb

@@ -2,6 +2,6 @@
 
 module Low
   module Loop
-    VERSION = '0.8.3'
+    VERSION = '0.8.4'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lowloop
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.4
 platform: ruby
 authors:
 - maedi