lowloop 0.8.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0cb4879d732cfa8bcceccce38ec1712d3ad5abd65fd5d06243301c3c7bc7fbfc
+  data.tar.gz: c40fa4f9fa6c7bb068b690ae91c66d3cc3b994bf9329bad57e88c738f356e667
+SHA512:
+  metadata.gz: 6a9ac09e3922269acf23efb9f257d69ae1835dd6775a41a0962e287524a9b1025a20da6836c7cc92fd64dbce6cd1dc98cd826b395a4477cc78ba3ee47636d7a1
+  data.tar.gz: d0b84d595b03f666a3b60dc7e14e011dc611a4c45dc49869fae240b6711b6af5b19a94c732f32cafbd67ed36f9dab789580c3d16c92c1166c46ea617b39c05da

data/lib/connections/connection_manager.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'io/wait'
+
+require_relative 'request_parser'
+require_relative '../responses/response_builder'
+
+module Low
+  class ConnectionManager
+    DEFAULT_KEEP_ALIVE_TIMEOUT = 30
+    DEFAULT_REQUEST_TIMEOUT = 10
+
+    def initialize(config:)
+      @config = config
+    end
+
+    def handle_connection(socket:)
+      stream = 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 = 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 = Events::RequestEvent.take(request:)
+        response = response_event.response
+
+        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
+
+    private
+
+    attr_reader :config
+  end
+end

data/lib/connections/request_parser.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'io/stream'
+require 'async/http'
+require 'protocol/http'
+
+module Low
+  class RequestParser
+    include LowType
+
+    class << self
+      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, full_path, = result
+        headers = parse_headers(stream:)
+        body = parse_body(stream:, method:, headers:)
+
+        ::Protocol::HTTP::Request.new('http', "#{host}:#{port}", method, full_path, version, headers, body)
+      end
+
+      private
+
+      # HTTP Request format:
+      #
+      # :verb :path HTTP/1.1\r\n
+      # :header_1\r\n
+      # :header_2\r\n
+      # :header_3\r\n
+      # \r\n
+      # :body
+      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.split(' ', 3)
+        path, query = full_path.split('?', 2)
+
+        [method, full_path, path, query]
+      end
+
+      def parse_headers(stream: IO::Stream::Generic) -> { ::Protocol::HTTP::Headers }
+        fields = []
+
+        # 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]
+        end
+
+        ::Protocol::HTTP::Headers.new(fields)
+      end
+
+      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(content_length)
+      end
+    end
+  end
+end

data/lib/events/file_event.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'lowevent'
+
+module Low
+  module Events
+    class FileEvent < LowEvent
+      attr_reader :file, :request
+
+      # TODO: For RouteEvent/FileEvent parse and provide query params as attributes on the event.
+      def initialize(file:, request: nil)
+        super(key: self.class, action: :request)
+
+        @file = file
+        @request = request
+      end
+    end
+  end
+end

data/lib/lowloop.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'async'
+require 'paint'
+require 'socket'
+require 'lowtype'
+require 'lowevent'
+require 'observers'
+
+require_relative 'responses/response_factory'
+require_relative 'connections/connection_manager'
+require_relative 'servers/file_server'
+require_relative 'support/low_frame'
+
+class LowLoop
+  include Observers
+
+  attr_reader :config
+
+  def initialize(config:, router: nil, renderer: nil, show_output: true)
+    @config = config
+    @connection_manager = Low::ConnectionManager.new(config:)
+    @frame = LowFrame.new(renderer:, fps: 10, show_output:)
+
+    Low::Events::RequestEvent.define do |observers|
+      observers << Low::FileServer.new(web_root: config.web_root, content_types: config.content_types)
+      observers << router if router
+      observers.push(self, action: :mirror) if config.mirror_mode
+    end
+  end
+
+  def start
+    server = start_server
+
+    Async do |task|
+      render_frame(task)
+
+      loop do
+        socket = server.accept
+
+        task.async do
+          @connection_manager.handle_connection(socket:)
+        rescue StandardError => e
+          render_error(e)
+        ensure
+          socket&.close
+        end
+      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
+    response = tories::ResponseFactory.html(body: "Thank you for visiting #{request.path} with body: '#{request.body}'")
+    Low::Events::ResponseEvent.new(response:)
+  end
+
+  # Consider LowLoop a value object in the context of Observers (there can only be one).
+  def ==(other) = other.class == self.class
+  def eql?(other) = self == other
+  def hash = [self.class].hash
+
+  private
+
+  def start_server
+    puts "Starting server @ #{config.host}:#{config.port}" unless config.matrix_mode
+
+    server = TCPServer.new(config.host, config.port)
+    server.listen(10)
+    server
+  end
+
+  def render_frame(task)
+    return unless @frame.renderer
+
+    task.async do
+      loop do
+        @frame.render
+        sleep 0.1 # 10fps
+      end
+    end
+  end
+
+  def render_error(error)
+    puts "\nException:"
+    puts Paint[error.message, :red]
+    puts ''
+
+    return unless @config.debug_mode
+
+    Fiber.blocking do
+      puts Paint[error.backtrace.join("\n"), :blue]
+      puts ''
+      puts 'Press ENTER to continue...'
+      gets
+    end
+  end
+end

data/lib/responses/file_response.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../responses/response_factory'
+
+module Low
+  class FileResponse
+    class << self
+      def request(event:)
+        file = event.file
+
+        if File.exist?(file.path)
+          response = ResponseFactory.file(path: file.path, content_type: file.content_type)
+          return Events::ResponseEvent.new(response:).tap(&:branch)
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/responses/response_builder.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Low
+  class ResponseBuilder
+    class << self
+      # TODO: Use Async wherever we can where it doesn't have "Task" requirement.
+      def respond(config:, socket:, response:, keep_alive: true)
+        file_body = response.body.respond_to?(:file)
+
+        if file_body
+          content_length = response.body.file.size
+        else
+          body_data = response.body.read || ''
+          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)
+
+        if file_body
+          IO.copy_stream(response.body.file, socket)
+        else
+          socket.write(body_data)
+        end
+      end
+
+      private
+
+      def write_status_line(socket, response)
+        socket.puts "#{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"
+      end
+
+      def write_response_headers(socket, 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"
+        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
+end

data/lib/responses/response_factory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'protocol/http'
+require 'protocol/http/body/file'
+
+module Low
+  class ResponseFactory
+    class << self
+      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
+
+      def file(path:, content_type:)
+        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:)
+        headers = Protocol::HTTP::Headers.new([['content-type', 'text/html']])
+
+        Protocol::HTTP::Response.new('HTTP/1.1', code, headers, nil)
+      end
+    end
+  end
+end

data/lib/servers/file_server.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'protocol/url'
+
+require_relative '../events/file_event'
+require_relative '../responses/file_response'
+require_relative '../states/file_state'
+
+module Low
+  class FileServer
+    include LowType
+    include Observers
+
+    def initialize(web_root:, content_types:)
+      @web_root = web_root
+      @content_types = content_types.transform_keys(&:to_s)
+
+      observers(Events::FileEvent) << FileResponse
+    end
+
+    def extension(file_path:)
+      extension = File.extname(file_path).delete_prefix('.')
+
+      return nil if extension == ''
+      return nil unless @content_types.key?(extension)
+
+      extension
+    end
+
+    def request(event: Events::RequestEvent)
+      file_path = event.request.path
+
+      return nil unless file_path.include?('.')
+
+      url = Protocol::URL[file_path]
+      extension = extension(file_path: url.path.to_s)
+      return nil if extension.nil?
+
+      file_path = url.local_path(@web_root)
+      file = States::FileState.new(path: file_path, content_type: @content_types[extension])
+
+      Events::FileEvent.take(file:, request: event.request)
+    end
+  end
+end

data/lib/states/file_state.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Low
+  module States
+    FileState = Data.define(:path, :content_type)
+  end
+end

data/lib/support/config_loader.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require 'yaml'
+
+module Low
+  class ConfigLoader
+    class << self
+      def load(filepath, env = {})
+        config_file = YAML.safe_load_file(filepath, symbolize_names: true)
+
+        # Environment variables override config file.
+        config_data = config_file.merge(env) do |_key, old_value, new_value|
+          new_value.nil? ? old_value : new_value
+        end
+
+        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,53 @@
+# 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
+
+    @last_frame = current_timestamp
+    @renderer.render(screen_size: @screen_size)
+  end
+
+  def setup
+    print "\e[?25l" # Hide cursor.
+    system 'clear'
+
+    resize
+
+    Signal.trap('WINCH') do
+      resize
+    end
+
+    Signal.trap('INT') do
+      print "\e[?25h\e[0m" # Show cursor and reset colors.
+      system 'clear'
+      exit
+    end
+  end
+
+  def resize
+    row_count, column_count = IO.console.winsize
+    @screen_size = { row_count:, column_count: }
+  end
+
+  private
+
+  def current_timestamp
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+  end
+end

data/lib/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Low
+  module Loop
+    VERSION = '0.8.1'
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: lowloop
+version: !ruby/object:Gem::Version
+  version: 0.8.1
+platform: ruby
+authors:
+- maedi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: io-stream
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: paint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: protocol-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: protocol-url
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: lowevent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: lowtype
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: An asynchronous server that creates events for your event-driven application
+  to use
+email:
+- maediprichard@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/connections/connection_manager.rb
+- lib/connections/request_parser.rb
+- lib/events/file_event.rb
+- lib/lowloop.rb
+- lib/responses/file_response.rb
+- lib/responses/response_builder.rb
+- lib/responses/response_factory.rb
+- lib/servers/file_server.rb
+- lib/states/file_state.rb
+- lib/support/config_loader.rb
+- lib/support/low_frame.rb
+- lib/version.rb
+homepage: https://github.com/low-rb/lowloop
+licenses: []
+metadata:
+  homepage_uri: https://github.com/low-rb/lowloop
+  source_code_uri: https://github.com/low-rb/lowloop/src/branch/main
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: An event-driven event loop
+test_files: []