low_loop 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d9fa2d555e127ad470c1eb71573c076d3484b08b833e184aa5c052b0de5a6af
-  data.tar.gz: 7a56cc04f846739e4dd957f66d6d558e40ab98c1fc69408fe82a6675f6101dec
+  metadata.gz: db3872b7a63b4b1fdb9036a98dce3f48ec8d85a0facd7fe42f8dd806a82cab17
+  data.tar.gz: 1dced9eafbbbc44921900cff33d734b8540ecd92a59a122f8654c7689f2d021a
 SHA512:
-  metadata.gz: 1e6d8044eee477441056a43a895c1314cbe14e99d170244ed9d75477c50b614c5ea29a6ac2dd245172dab8870cdca6d70bfec5b9c4ca2065dce8468be5b12e8c
-  data.tar.gz: 1923f95b047d33bccd17fe9b48b63a84dfa80ac30497d25b5989bdffdf1ff50f554898b0e2a5d7fcdc4ceda175f02f4da6dff6dca0c60d94f063a5801d45e9f2
+  metadata.gz: d80a7cf83f40792f60f2652c13583b130e770ca31272f2ab3e5796b7ec232e581d1a48b41030247f18a6fdfa685457a6790b78b29211a167f7e5df14da2328fb
+  data.tar.gz: aab2f0b8a6a4450ddf9f5c2b1a9226abb0cc168aee50ed4c081e1ac2c4a54c83fcab57d80102c505b3dba8bcd35651a8544e72fa5eac9c80357d393b654cc3a4

data/lib/factories/response_factory.rb

@@ -11,7 +11,7 @@ module Low
           headers = Protocol::HTTP::Headers.new(['content-type', 'text/html'])
           body = Protocol::HTTP::Body::Buffered.wrap(body)
 
-          Protocol::HTTP::Response.new('http/1.1', 200, headers, body)
+          Protocol::HTTP::Response.new('HTTP/1.1', 200, headers, body)
         end
 
         def file(path:, content_type:)
@@ -19,7 +19,7 @@ module Low
           file = File.open(path, 'rb')
           body = Protocol::HTTP::Body::File.new(file)
 
-          Protocol::HTTP::Response.new('http/1.1', 200, headers, body)
+          Protocol::HTTP::Response.new('HTTP/1.1', 200, headers, body)
         end
       end
     end

data/lib/low_loop.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'async'
+require 'io/wait'
 require 'socket'
 require 'low_type'
 require 'low_event'
@@ -15,11 +16,14 @@ require_relative 'support/low_frame'
 class LowLoop
   include Observers
 
+  DEFAULT_KEEP_ALIVE_TIMEOUT = 30
+  DEFAULT_REQUEST_TIMEOUT = 10
+
   attr_reader :config
 
   def initialize(config:, router: nil, renderer: nil, show_output: true)
     @config = config
-    @frame = LowFrame.new(renderer:, fps: 30, show_output:)
+    @frame = LowFrame.new(renderer:, fps: 10, show_output:)
 
     observers(Low::Events::RequestEvent) << Low::FileServer.new(web_root: config.web_root, content_types: config.content_types)
     observers(Low::Events::RequestEvent) << router if router
@@ -30,20 +34,21 @@ class LowLoop
   def start
     server = start_server
 
-    Fiber.set_scheduler(Async::Scheduler.new)
+    Async do |task|
+      # Background task.
+      task.async do
+        loop do
+          @frame.render if @frame.renderer
+          sleep 0.1 # 10fps
+        end
+      end
 
-    Fiber.schedule do
+      # Request handler.
       loop do
         socket = server.accept
 
-        @frame.render if @frame.renderer
-
-        Fiber.schedule do
-          request = Low::RequestParser.parse(socket:, host: config.host, port: config.port)
-          response_event = Low::Events::RequestEvent.take(request:)
-          response = response_event.response
-
-          Low::ResponseBuilder.respond(config:, socket:, response:)
+        task.async do
+          handle_connection(socket)
         rescue StandardError => e
           puts e.message
         ensure
@@ -61,6 +66,14 @@ class LowLoop
     server
   end
 
+  def render
+    Async do
+      loop do
+        @frame.render
+      end
+    end
+  end
+
   # 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
@@ -72,4 +85,54 @@ class LowLoop
   def ==(other) = other.class == self.class
   def eql?(other) = self == other
   def hash = [self.class].hash
+
+  private
+
+  def handle_connection(socket)
+    stream = Low::RequestParser.create_stream(socket:)
+    keep_alive = true
+    version = nil
+
+    while keep_alive
+      break unless socket.wait_readable(keep_alive_timeout)
+
+      socket.timeout = request_timeout
+      begin
+        request = Low::RequestParser.parse(stream:, host: config.host, port: config.port, version:)
+      rescue IO::TimeoutError
+        break
+      ensure
+        socket.timeout = nil
+      end
+      break if request.nil?
+
+      version ||= request.version
+      keep_alive = keep_alive?(request)
+
+      response_event = Low::Events::RequestEvent.take(request:)
+      response = response_event.response
+
+      Low::ResponseBuilder.respond(config:, socket:, response:, keep_alive:)
+    end
+  end
+
+  def keep_alive?(request)
+    tokens = (request.headers['connection'] || []).flat_map do |value|
+      value.split(',').map { |token| token.strip.downcase }
+    end
+
+    if request.version.to_s.downcase.include?('1.0')
+      tokens.include?('keep-alive')
+    else
+      !tokens.include?('close')
+    end
+  end
+
+  def keep_alive_timeout
+    config.keep_alive_timeout || DEFAULT_KEEP_ALIVE_TIMEOUT
+  end
+
+  def request_timeout
+    config.request_timeout || DEFAULT_REQUEST_TIMEOUT
+  end
 end

data/lib/requests/request_parser.rb

@@ -9,15 +9,21 @@ module Low
     include LowType
 
     class << self
-      def parse(socket: TCPSocket, host: String, port: Integer) -> { ::Protocol::HTTP::Request }
-        stream = IO::Stream(socket)
-        protocol = Async::HTTP::Protocol::HTTP.default.protocol_for(stream)
+      def create_stream(socket: TCPSocket) -> { IO::Stream::Generic }
+        IO::Stream(socket)
+      end
+
+      def parse(stream: IO::Stream::Generic, host: String, port: Integer, version: nil) -> { ::Protocol::HTTP::Request | nil }
+        version ||= Async::HTTP::Protocol::HTTP.default.protocol_for(stream)::VERSION
+
+        result = parse_request(stream:)
+        return nil unless result
 
-        method, path, = parse_request(stream:)
+        method, full_path, = result
         headers = parse_headers(stream:)
-        body = parse_body(stream:, method:)
+        body = parse_body(stream:, method:, headers:)
 
-        ::Protocol::HTTP::Request.new('http', "#{host}:#{port}", method, path, protocol::VERSION, headers, body)
+        ::Protocol::HTTP::Request.new('http', "#{host}:#{port}", method, full_path, version, headers, body)
       end
 
       private
@@ -30,23 +36,25 @@ module Low
       # :header_3\r\n
       # \r\n
       # :body
-      #
-      # TODO: Handle type for namespaced "IO:Stream".
-      def parse_request(stream:)
-        request_line = stream.gets || raise(StandardError, 'EOF')
+      def parse_request(stream: IO::Stream::Generic)
+        request_line = stream.gets || return
+
+        request_line = request_line.strip
+        return nil if request_line.empty?
 
-        method, full_path, _http_version = request_line.strip.split(' ', 3)
+        method, full_path, _http_version = request_line.split(' ', 3)
         path, query = full_path.split('?', 2)
 
         [method, full_path, path, query]
       end
 
-      # TODO: Handle namespaced stream type "IO:Stream".
-      def parse_headers(stream:) -> { ::Protocol::HTTP::Headers }
+      def parse_headers(stream: IO::Stream::Generic) -> { ::Protocol::HTTP::Headers }
         fields = []
 
-        while (line = stream.gets.strip)
-          break if line.strip.empty?
+        # Sometimes returns nil which represents a client disconnect mid-request.
+        while (line = stream.gets)
+          line = line.strip
+          break if line.empty?
 
           key, value = line.split(/:\s/, 2)
           fields << [key, value]
@@ -55,10 +63,13 @@ module Low
         ::Protocol::HTTP::Headers.new(fields)
       end
 
-      def parse_body(stream:, method:)
-        return nil unless %w[POST PUT].include?(method)
+      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?
 
-        stream.read
+        stream.read(content_length)
       end
     end
   end

data/lib/responses/response_builder.rb

@@ -4,23 +4,50 @@ module Low
   class ResponseBuilder
     class << self
       # TODO: Use Async wherever we can where it doesn't have "Task" requirement.
-      def respond(config:, socket:, response:)
-        socket.puts "#{response.version} #{response.status}\r\n"
-        socket.puts config.port.nil? ? "Host: #{config.host}\r\n" : "Host: #{config.host}:#{config.port}\r\n"
+      def respond(config:, socket:, response:, keep_alive: true)
+        file_body = response.body.respond_to?(:file)
 
-        response.headers.fields.each_slice(2) do |key, value|
-          socket.puts "#{key}: #{value}\r\n"
+        if file_body
+          content_length = response.body.file.size
+        else
+          body_data = response.body.read || ''
+          content_length = body_data.bytesize
         end
 
-        socket.puts "\r\n"
+        write_status_line(socket, response)
+        write_host_header(socket, config)
+        write_response_headers(socket, response)
+        write_final_headers(socket, content_length, keep_alive)
 
-        if response.body.respond_to?(:file)
+        if file_body
           IO.copy_stream(response.body.file, socket)
         else
-          socket.puts(response.body.read)
+          socket.write(body_data)
         end
+      end
+
+      private
+
+      def write_status_line(socket, response)
+        socket.puts "#{response.version} #{response.status}\r\n"
+      end
 
-        socket.close
+      def write_host_header(socket, config)
+        socket.puts config.port.nil? ? "Host: #{config.host}\r\n" : "Host: #{config.host}:#{config.port}\r\n"
+      end
+
+      def write_response_headers(socket, response)
+        response.headers.fields.each_slice(2) do |key, value|
+          next if %w[content-length connection].include?(key.to_s.downcase)
+
+          socket.puts "#{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"
       end
     end
   end

data/lib/support/low_frame.rb

@@ -5,28 +5,25 @@ require 'io/console'
 class LowFrame
   attr_reader :screen_size, :renderer
 
-  def initialize(renderer:, fps: 30, show_output: true)
+  def initialize(renderer:, fps: 10, show_output: true)
     @renderer = renderer
     @show_output = show_output
 
     # Millisecond duration of each frame. We lose a small amount of precision dropping the decimal.
     @frame_time = ((1.0 / fps) * 1000).to_i
-
-    row_count, column_count = IO.console.winsize
-    @screen_size = { row_count:, column_count: }
-
     @last_frame = nil
 
     setup if renderer && show_output
   end
 
   def render
-    if @last_frame.nil? || (current_timestamp - @last_frame) >= @frame_time
-      system 'clear' if @show_output
+    return unless @last_frame.nil? || (current_timestamp - @last_frame) >= @frame_time
 
-      @last_frame = current_timestamp
-      @renderer.render(screen_size: @screen_size)
-    end
+    row_count, column_count = IO.console.winsize
+    @screen_size = { row_count:, column_count: }
+
+    @last_frame = current_timestamp
+    @renderer.render(screen_size: @screen_size)
   end
 
   def setup
@@ -39,11 +36,11 @@ class LowFrame
   end
 
   def exit
-    trap('INT') {
+    trap('INT') do
       reset
       system 'clear'
       exit
-    }
+    end
   end
 
   private

data/lib/version.rb

@@ -2,6 +2,6 @@
 
 module Low
   module Loop
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_loop
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - maedi