syntropy 0.28.2 → 0.29.0

data/test/test_server.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require_relative './helper'
+
+class ServerTest < Minitest::Test
+  def make_socket_pair
+    port = 10000 + rand(30000)
+    server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    @machine.bind(server_fd, '127.0.0.1', port)
+    @machine.listen(server_fd, UM::SOMAXCONN)
+
+    client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.connect(client_conn_fd, '127.0.0.1', port)
+
+    server_conn_fd = @machine.accept(server_fd)
+
+    @machine.close(server_fd)
+    [client_conn_fd, server_conn_fd]
+  end
+
+  class STOP < StandardError
+  end
+
+  def setup(opts = {})
+    @machine = UM.new
+    @port = 10000 + rand(30000)
+    @env = { bind: "127.0.0.1:#{@port}" }.merge(opts)
+    @server = Syntropy::Server.new(@machine, @env) { @app&.call(it) }
+    @f_server = @machine.spin { run_server }
+
+    # let server spin and listen to incoming connections
+    @machine.sleep(0.01)
+
+    @client_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.connect(@client_fd, '127.0.0.1', @port)
+  end
+
+  def run_server
+    @server.run
+  ensure
+    @server_done = true
+  end
+
+  def teardown
+    @machine.close(@client_fd) rescue nil
+    @server.stop!
+    @machine.snooze until @server_done
+  end
+
+  def write_http_request(msg)
+    @machine.send(@client_fd, msg, msg.bytesize, UM::MSG_WAITALL)
+  end
+
+  def write_client_side(msg)
+    @machine.send(@client_fd, msg, msg.bytesize, UM::MSG_WAITALL)
+  end
+
+  def read_client_side(len = 65536)
+    buf = +''
+    res = @machine.recv(@client_fd, buf, len, 0)
+    res == 0 ? nil : buf
+  end
+
+  def test_http_1_0_response
+    @app = ->(req) {
+      req.respond('Hello, world!', {})
+    }
+
+    write_http_request "GET / HTTP/1.0\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 505\r\nTransfer-Encoding: chunked\r\n\r\n1a\r\nHTTP version not supported\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_basic_app_response
+    @app = ->(req) {
+      req.respond('Hello, world!', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_pipelined_requests
+    @app = ->(req) {
+      req.respond("method: #{req.method}")
+    }
+
+    write_http_request "GET /foo HTTP/1.1\r\nServer: foo.com\r\n\r\nSCHmet /bar HTTP/1.1\r\n\r\n"
+
+    @machine.sleep(0.1)
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nb\r\nmethod: get\r\n0\r\n\r\n" +
+               "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\ne\r\nmethod: schmet\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_graceful_shutdown
+    @app = ->(req) do
+      @machine.sleep(1)
+      req.respond('Hello, world!', {})
+    rescue UM::Terminate
+      req.respond('Terminated!', {})
+      raise
+    end
+
+    write_http_request "GET /foo HTTP/1.1\r\nServer: foo.com\r\n\r\nSCHMET /bar HTTP/1.1\r\n\r\n"
+
+    @machine.sleep(0.01)
+    @server.stop!
+    @machine.snooze
+
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nb\r\nTerminated!\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_pipelined_requests_with_body
+    @bodies = []
+    @reqs = []
+    @app = ->(req) {
+      @reqs << req
+      @bodies << req.read
+      req.respond("method: #{req.method}")
+    }
+
+    msg = <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+      Content-Length: 3
+
+      abcSCHMOST /bar HTTP/1.1
+      Server: bar.com
+      Content-Length: 6
+
+      defghi
+    HTTP
+    write_http_request msg
+
+    read_client_side
+    assert_equal 2, @bodies.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method' => 'post',
+      ':path' => '/foo',
+      ':protocol' => 'http/1.1',
+      'server' => 'foo.com',
+      'content-length' => '3',
+      ':body-done-reading' => true,
+      ':tx' => 56,
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'abc', body
+
+    req1 = @reqs.shift
+    headers = req1.headers
+    assert_equal({
+      ':method' => 'schmost',
+      ':path' => '/bar',
+      ':protocol' => 'http/1.1',
+      'server' => 'bar.com',
+      'content-length' => '6',
+      ':body-done-reading' => true,
+      ':tx' => 59,
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'defghi', body
+  end
+
+  def test_pipelined_requests_with_body_chunked
+    @bodies = []
+    @reqs = []
+    @app = ->(req) do
+      @reqs << req
+      @bodies << (b = req.read)
+      req.respond("method: #{req.method}")
+    rescue => e
+      p e
+      p e.backtrace
+      exit!
+    end
+
+    msg = <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+      Transfer-Encoding: chunked
+
+      3
+      abc
+      2
+      de
+      0
+
+      SCHMOST /bar HTTP/1.1
+      Server: bar.com
+      Transfer-Encoding: chunked
+
+      1f
+      123456789abcdefghijklmnopqrstuv
+      0
+
+
+
+    HTTP
+
+    write_http_request msg
+    read_client_side
+    read_client_side
+    assert_equal 2, @bodies.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method'             => 'post',
+      ':path'               => '/foo',
+      ':protocol'           => 'http/1.1',
+      'server'              => 'foo.com',
+      'transfer-encoding'   => 'chunked',
+      ':body-done-reading'  => true,
+      ':tx'                 => 56
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'abcde', body
+
+    req1 = @reqs.shift
+    headers = req1.headers
+    assert_equal({
+      ':method'             => 'schmost',
+      ':path'               => '/bar',
+      ':protocol'           => 'http/1.1',
+      'server'              => 'bar.com',
+      'transfer-encoding'   => 'chunked',
+      ':body-done-reading'  => true,
+      ':tx'                 => 59
+    }, headers)
+    body = @bodies.shift
+    assert_equal '123456789abcdefghijklmnopqrstuv', body
+  end
+
+  class TestLogger
+    attr_reader :entries
+
+    def initialize
+      @entries = []
+    end
+
+    def info(o)
+      @entries << o.merge(level: :INFO)
+    end
+
+    def error(o)
+      @entries << o.merge(level: :ERROR)
+    end
+  end
+
+  def test_logging
+    skip
+    reqs = []
+    @env[:logger] = TestLogger.new
+    @app = ->(req) { reqs << req; req.respond('Hello, world!', {}) }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+
+    entries = @env[:logger].entries
+    assert_equal 1, entries.size
+    assert_equal 1, reqs.size
+
+    assert_equal reqs.first, entries.first[:request]
+  end
+
+  def test_server_headers
+    @env[:server_headers] = "Server: Tipi\r\n"
+
+    @app = ->(req) {
+      req.respond('Hello, world!', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: Tipi\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_date
+    setup({ server_extensions: { date: true } })
+    @machine.sleep(0.1)
+    assert_kind_of Time, @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nDate: #{@env[:server_date].httpdate}\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_date_and_server_name
+    setup({ server_extensions: { date: true, name: 'Foo' } })
+    @machine.sleep(0.1)
+    assert_kind_of Time, @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: Foo\r\nDate: #{@env[:server_date].httpdate}\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_server_name
+    setup({ server_extensions: { name: 'Bar' } })
+    @machine.sleep(0.1)
+    assert_nil @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: Bar\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: syntropy
 version: !ruby/object:Gem::Version
-  version: 0.28.2
+  version: 0.29.0
 platform: ruby
 authors:
 - Sharon Rosner
@@ -51,34 +51,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.24'
-- !ruby/object:Gem::Dependency
-  name: tp2
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.20.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.20.2
 - !ruby/object:Gem::Dependency
   name: uringmachine
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.24.0
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.24.0
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: listen
   requirement: !ruby/object:Gem::Requirement
@@ -159,6 +145,7 @@ files:
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
@@ -209,16 +196,18 @@ files:
 - lib/syntropy/applets/builtin/json_api.js
 - lib/syntropy/applets/builtin/ping.rb
 - lib/syntropy/applets/builtin/req.rb
+- lib/syntropy/connection.rb
 - lib/syntropy/connection_pool.rb
 - lib/syntropy/dev_mode.rb
 - lib/syntropy/errors.rb
-- lib/syntropy/file_watch.rb
 - lib/syntropy/json_api.rb
+- lib/syntropy/logger.rb
 - lib/syntropy/markdown.rb
 - lib/syntropy/module.rb
 - lib/syntropy/papercraft_extensions.rb
 - lib/syntropy/request_extensions.rb
 - lib/syntropy/routing_tree.rb
+- lib/syntropy/server.rb
 - lib/syntropy/side_run.rb
 - lib/syntropy/utils.rb
 - lib/syntropy/version.rb
@@ -259,13 +248,14 @@ files:
 - test/run.rb
 - test/test_app.rb
 - test/test_caching.rb
+- test/test_connection.rb
 - test/test_connection_pool.rb
 - test/test_errors.rb
-- test/test_file_watch.rb
 - test/test_json_api.rb
 - test/test_module.rb
 - test/test_request_extensions.rb
 - test/test_routing_tree.rb
+- test/test_server.rb
 - test/test_side_run.rb
 homepage: https://github.com/digital-fabric/syntropy
 licenses:
@@ -273,10 +263,10 @@ licenses:
 metadata:
   homepage_uri: https://github.com/digital-fabric/syntropy
   documentation_uri: https://www.rubydoc.info/gems/syntropy
-  changelog_uri: https://github.com/digital-fabric/syntropy/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/digital-fabric/syntropy/blob/main/CHANGELOG.md
 rdoc_options:
 - "--title"
-- Extralite
+- Syntropy
 - "--main"
 - README.md
 require_paths:
@@ -292,7 +282,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Syntropic Web Framework
 test_files: []

data/lib/syntropy/file_watch.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Syntropy
-  def self.file_watch(machine, *roots, period: 0.1, &block)
-    raise 'Missing root paths' if roots.empty?
-
-    require 'listen'
-
-    queue = Thread::Queue.new
-    listener = Listen.to(*roots) do |modified, added, removed|
-      modified.each { queue.push([:modified, it]) }
-      added.each    { queue.push([:added, it]) }
-      removed.each  { queue.push([:removed, it]) }
-    end
-    listener.start
-
-    loop do
-      machine.sleep(period) while queue.empty?
-      event, fn = queue.shift
-      block.call(event, fn)
-    end
-  rescue StandardError => e
-    p e
-    p e.backtrace
-  ensure
-    listener.stop
-  end
-end

data/test/test_file_watch.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require_relative 'helper'
-
-class FileWatchTest < Minitest::Test
-  def setup
-    @machine = UM.new
-    @root = "/tmp/syntropy/#{rand(1000000).to_s(16)}"
-    FileUtils.mkdir_p(@root)
-  end
-
-  def test_file_watch
-    queue = UM::Queue.new
-
-    f = @machine.spin do
-      Syntropy.file_watch(@machine, @root, period: 0.01) { |event, fn| @machine.push(queue, [event, fn]) }
-    end
-    @machine.sleep(0.05)
-    assert_equal 0, queue.count
-
-    fn = File.join(@root, 'foo.bar')
-    IO.write(fn, 'abc')
-    assert_equal [:added, fn], @machine.shift(queue)
-
-    fn = File.join(@root, 'foo.bar')
-    IO.write(fn, 'def')
-    assert_equal [:modified, fn], @machine.shift(queue)
-
-    FileUtils.rm(fn)
-    assert_equal [:removed, fn], @machine.shift(queue)
-  ensure
-    @machine.schedule(f, UM::Terminate)
-    # @machine.join(f)
-  end
-end