low_loop 0.3.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13f02bd5602a0a6f93f9fdf80a937c0bc8adf20bbb2ad30fbd4860475011e02f
-  data.tar.gz: 4023be91bfbcab20c048dd54201fa80fc3926ab83d17c4d90d52c92dd839155c
+  metadata.gz: db3872b7a63b4b1fdb9036a98dce3f48ec8d85a0facd7fe42f8dd806a82cab17
+  data.tar.gz: 1dced9eafbbbc44921900cff33d734b8540ecd92a59a122f8654c7689f2d021a
 SHA512:
-  metadata.gz: 9b8974c79439798a63e993f9002fa08829f754a6e2d3b31083f9ee6b7613d8398cd57074d284c14be74fb70bf7bdf26f4bfba33bd5fe65feddb39d14188efca3
-  data.tar.gz: d55c83e3bf308b5a569e48c5ffb7333df45d240ba67c220faf27795d6c297076faa95c8e53340daab1c13e07705fc4d6f67fab19b73893a9f815046ad5b2205d
+  metadata.gz: d80a7cf83f40792f60f2652c13583b130e770ca31272f2ab3e5796b7ec232e581d1a48b41030247f18a6fdfa685457a6790b78b29211a167f7e5df14da2328fb
+  data.tar.gz: aab2f0b8a6a4450ddf9f5c2b1a9226abb0cc168aee50ed4c081e1ac2c4a54c83fcab57d80102c505b3dba8bcd35651a8544e72fa5eac9c80357d393b654cc3a4

data/lib/events/file_event.rb

@@ -9,7 +9,7 @@ module Low
 
       # TODO: For RouteEvent/FileEvent parse and provide query params as attributes on the event.
       def initialize(file:, request: nil)
-        super()
+        super(key: self.class)
 
         @file = file
         @request = request

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'
@@ -10,36 +11,44 @@ require_relative 'factories/response_factory'
 require_relative 'requests/request_parser'
 require_relative 'responses/response_builder'
 require_relative 'servers/file_server'
+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)
+  def initialize(config:, router: nil, renderer: nil, show_output: true)
     @config = config
+    @frame = LowFrame.new(renderer:, fps: 10, show_output:)
 
-    observers << Low::FileServer.new(web_root: config.web_root, content_types: config.content_types)
-    observers << router if router
+    observers(Low::Events::RequestEvent) << Low::FileServer.new(web_root: config.web_root, content_types: config.content_types)
+    observers(Low::Events::RequestEvent) << router if router
 
-    observers.push(self, action: :mirror) if config.mirror_mode
+    observers.push(Low::Events::RequestEvent, action: :mirror) if config.mirror_mode
   end
 
   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
 
-        Fiber.schedule do
-          request = Low::RequestParser.parse(socket:, host: config.host, port: config.port)
-          response_event = take(event: Low::Events::RequestEvent.new(request:))
-          response = response_event.response
-
-          Low::ResponseBuilder.respond(config:, socket:, response:)
+        task.async do
+          handle_connection(socket)
         rescue StandardError => e
           puts e.message
         ensure
@@ -57,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
@@ -68,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/config_loader.rb

@@ -16,6 +16,13 @@ module Low
 
         OpenStruct.new(config_data)
       end
+
+      def parse_boolean(value)
+        return true if value == '1'
+        return false if value == '0'
+
+        nil
+      end
     end
   end
 end

data/lib/support/low_frame.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+class LowFrame
+  attr_reader :screen_size, :renderer
+
+  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
+    @last_frame = nil
+
+    setup if renderer && show_output
+  end
+
+  def render
+    return unless @last_frame.nil? || (current_timestamp - @last_frame) >= @frame_time
+
+    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
+    print "\e[?25l" # Hide cursor.
+    system 'clear'
+  end
+
+  def reset
+    print "\e[?25h\e[0m" # Show cursor and reset colors.
+  end
+
+  def exit
+    trap('INT') do
+      reset
+      system 'clear'
+      exit
+    end
+  end
+
+  private
+
+  def current_timestamp
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+  end
+end

data/lib/version.rb

@@ -2,6 +2,6 @@
 
 module Low
   module Loop
-    VERSION = '0.3.2'
+    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.3.2
+  version: 0.5.0
 platform: ruby
 authors:
 - maedi
@@ -124,7 +124,7 @@ files:
 - lib/servers/file_server.rb
 - lib/states/file_state.rb
 - lib/support/config_loader.rb
-- lib/support/config_support.rb
+- lib/support/low_frame.rb
 - lib/version.rb
 homepage: https://github.com/low-rb/low_loop
 licenses: []
@@ -145,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.6
 specification_version: 4
 summary: An event-driven event loop
 test_files: []

data/lib/support/config_support.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Low
-  module ConfigSupport
-    class << self
-      def parse_boolean(value)
-        return true if value == '1'
-        return false if value == '0'
-
-        nil
-      end
-    end
-  end
-end