syntropy 0.28.1 → 0.29.0

data/lib/syntropy/request_extensions.rb

@@ -3,6 +3,32 @@
 require 'qeweney'
 require 'json'
 
+class Qeweney::Request
+  attr_accessor :start_stamp
+
+  def respond_with_static_file(path, etag, last_modified, opts)
+    cache_headers = (etag || last_modified) ? {
+      'etag' => etag,
+      'last-modified' => last_modified
+    } : {}
+
+    adapter.respond_with_static_file(self, path, opts, cache_headers)
+  end
+
+  def set_response_headers(headers)
+    adapter.set_response_headers(headers)
+  end
+
+  def set_cookie(*)
+    adapter.set_cookie(*)
+  end
+
+  def upgrade(protocol, custom_headers = nil, &block)
+    super(protocol, custom_headers)
+    adapter.with_stream(&block)
+  end
+end
+
 module Syntropy
   # Extensions for the Qeweney::Request class
   module RequestExtensions
@@ -37,9 +63,9 @@ module Syntropy
     # @param accepted [Array<String>] list of accepted HTTP methods
     # @return [String] request's HTTP method
     def validate_http_method(*accepted)
-      raise Syntropy::Error.method_not_allowed if !accepted.include?(method)
+      return method if accepted.include?(method)
 
-      method
+      raise Syntropy::Error.method_not_allowed
     end
 
     # Responds according to the given map. The given map defines the responses

data/lib/syntropy/server.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'syntropy/connection'
+require 'syntropy/request_extensions'
+
+module Syntropy
+  class Server
+    PENDING_REQUESTS_GRACE_PERIOD = 0.1
+    PENDING_REQUESTS_TIMEOUT_PERIOD = 5
+
+    def self.syntropy_app(_machine, env)
+      if env[:app_location]
+        env[:logger]&.info(message: 'Loading web app', location: env[:app_location])
+        require env[:app_location]
+
+        env.merge!(Syntropy.config)
+      end
+      env[:app]
+    end
+
+    def self.static_app(env); end
+
+    def initialize(machine, env, &app)
+      @machine = machine
+      @env = env
+      @app = app || app_from_env
+      @server_fds = []
+      @accept_fibers = []
+    end
+
+    def app_from_env
+      case @env[:app_type]
+      when nil, :syntropy
+        Server.syntropy_app(@machine, @env)
+      when :static
+        Server.static_app(@env)
+      else
+        raise "Invalid app type #{@env[:app_type].inspect}"
+      end
+    end
+
+    def run
+      setup
+      @machine.await(@accept_fibers)
+    rescue UM::Terminate
+      graceful_shutdown
+    end
+
+    def stop!
+      graceful_shutdown
+    end
+
+    private
+
+    def setup
+      bind_info = get_bind_entries
+      bind_info.each do |(host, port)|
+        fd = setup_server_socket(host, port)
+        @server_fds << fd
+        @accept_fibers << @machine.spin { accept_incoming(fd) }
+      end
+      bind_string = bind_info.map { it.join(':') }.join(', ')
+      @env[:logger]&.info(message: "Listening on #{bind_string}")
+      setup_server_extensions
+
+      # map fibers
+      @connection_fibers = Set.new
+    end
+
+    def get_bind_entries
+      bind = @env[:bind]
+      case bind
+      when Array
+        bind.map { bind_info(it) }
+      when String
+        [bind_info(bind)]
+      else
+        # default
+        [['0.0.0.0', 1234]]
+      end
+    end
+
+    def bind_info(bind_string)
+      parts = bind_string.split(':')
+      [parts[0], parts[1].to_i]
+    end
+
+    def setup_server_socket(host, port)
+      fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+      @machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+      @machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEPORT, true)
+      @machine.bind(fd, host, port)
+      @machine.listen(fd, UM::SOMAXCONN)
+      fd
+    end
+
+    def setup_server_extensions
+      extensions = @env[:server_extensions]
+      return if !extensions
+
+      server_name = extensions[:name]
+      if extensions[:date]
+        @date_header_fiber = @machine.spin {
+          @machine.periodically(1) { update_server_headers(server_name) }
+        }
+        update_server_headers(server_name)
+      elsif server_name
+        @env[:server_headers] = "Server: #{server_name}\r\n"
+      end
+    end
+
+    def update_server_headers(server_name)
+      @env[:server_date] = Time.now
+      if server_name
+        @env[:server_headers] = "Server: #{server_name}\r\nDate: #{@env[:server_date].httpdate}\r\n"
+      else
+        @env[:server_headers] = "Date: #{Time.now.httpdate}\r\n"
+      end
+    end
+
+    def accept_incoming(listen_fd)
+      @machine.accept_each(listen_fd) { start_client_connection(it) }
+    rescue UM::Terminate
+      # terminated
+    end
+
+    def start_client_connection(fd)
+      conn = Connection.new(self, @machine, fd, @env, &@app)
+      f = @machine.spin(conn) do
+        it.run
+      ensure
+        @connection_fibers.delete(f)
+      end
+      @connection_fibers << f
+    end
+
+    def close_all_server_fds
+      @server_fds.each { @machine.close_async(it) }
+    end
+
+    STOP = UM::Terminate.new
+
+    def stop_accept_fibers
+      @accept_fibers.each { @machine.schedule(it, STOP) if !it.done? }
+      @machine.await(@accept_fibers)
+    end
+
+    def graceful_shutdown
+      @env[:logger]&.info(message: 'Shutting down gracefully...')
+
+      # stop listening
+      close_all_server_fds
+      stop_accept_fibers
+      @machine.snooze
+
+      return if @connection_fibers.empty?
+
+      # sleep for a bit, let requests finish
+      @machine.sleep(PENDING_REQUESTS_GRACE_PERIOD)
+      return if @connection_fibers.empty?
+
+      # terminate pending fibers
+      pending = @connection_fibers.to_a
+      pending.each { @machine.schedule(it, STOP) }
+
+      @machine.timeout(PENDING_REQUESTS_TIMEOUT_PERIOD, UM::Terminate) do
+        @machine.await(@connection_fibers)
+      rescue UM::Terminate
+        # timeout on waiting for adapters to finish running, do nothing
+      end
+    end
+  end
+end

data/lib/syntropy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Syntropy
-  VERSION = '0.28.1'
+  VERSION = '0.29.0'
 end

data/lib/syntropy.rb

@@ -2,9 +2,11 @@
 
 require 'qeweney'
 require 'uringmachine'
-require 'tp2'
 require 'papercraft'
 
+require 'syntropy/logger'
+require 'syntropy/connection'
+require 'syntropy/server'
 require 'syntropy/app'
 require 'syntropy/connection_pool'
 require 'syntropy/errors'
@@ -16,6 +18,7 @@ require 'syntropy/routing_tree'
 require 'syntropy/json_api'
 require 'syntropy/side_run'
 require 'syntropy/utils'
+require 'syntropy/version'
 
 module Syntropy
   Status = Qeweney::Status
@@ -50,4 +53,52 @@ module Syntropy
     "  #{GREEN}  #{YELLOW}|#{GREEN}  vvv o    #{CLEAR}https://github.com/digital-fabric/syntropy\n"\
     "  #{GREEN} :#{YELLOW}|#{GREEN}:::#{YELLOW}|#{GREEN}::#{YELLOW}|#{GREEN}:\n"\
     "#{YELLOW}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++\e[0m\n\n"
+
+  class << self
+    def run(env = {}, &app)
+      if @in_run
+        @env = env
+        @env[:app] = app if app
+        return
+      end
+
+      env ||= @env || {}
+      begin
+        @in_run = true
+        machine = env[:machine] || UM.new
+        machine.puts(env[:banner]) if env[:banner]
+
+        env[:logger]&.info(message: "Running Syntropy #{Syntropy::VERSION}, UringMachine #{UM::VERSION}, Ruby #{RUBY_VERSION}")
+
+        server = Server.new(machine, env, &app)
+
+        setup_signal_handling(machine, Fiber.current)
+        server.run
+      ensure
+        @in_run = false
+      end
+    end
+
+    def env(env = nil, &app)
+      return @env if !env && !app
+
+      @env = env || {}
+      @env[:app] = app if app
+    end
+
+    private
+
+    def setup_signal_handling(machine, fiber)
+      queue = UM::Queue.new
+      trap('SIGINT') { machine.push(queue, :SIGINT) }
+      machine.spin { watch_for_int_signal(machine, queue, fiber) }
+    end
+
+    # waits for signal from queue, then terminates given fiber
+    # to be done
+    def watch_for_int_signal(machine, queue, fiber)
+      machine.shift(queue)
+      machine.schedule(fiber, UM::Terminate.new)
+    end
+  end
 end

data/syntropy.gemspec

@@ -13,9 +13,9 @@ Gem::Specification.new do |s|
   s.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'
   }
-  s.rdoc_options  = ['--title', 'Extralite', '--main', 'README.md']
+  s.rdoc_options  = ['--title', 'Syntropy', '--main', 'README.md']
   s.extra_rdoc_files = ['README.md']
   s.require_paths = ['lib']
   s.required_ruby_version = '>= 3.4'
@@ -24,11 +24,10 @@ Gem::Specification.new do |s|
   s.add_dependency 'extralite',     '~>2.14'
   s.add_dependency 'papercraft',    '~>3.2.0'
   s.add_dependency 'qeweney',       '~>0.24'
-  s.add_dependency 'tp2',           '~>0.20.1'
-  s.add_dependency 'uringmachine',  '~>0.23.1'
+  s.add_dependency 'uringmachine',  '~>1.0.0'
 
   s.add_dependency 'listen',        '~>3.9.0'
-  
+
   s.add_dependency 'json'
   s.add_dependency 'logger'
 

data/test/helper.rb

@@ -11,6 +11,12 @@ require 'fileutils'
 STDOUT.sync = true
 STDERR.sync = true
 
+class ::String
+  def crlf_lines
+    chomp.gsub("\n", "\r\n").chomp
+  end
+end
+
 module ::Kernel
   def mock_req(headers, body = nil)
     Qeweney::MockAdapter.mock(headers, body).tap { it.setup_mock_request }
@@ -113,5 +119,3 @@ class Qeweney::Request
     response_headers['Content-Type']
   end
 end
-
-# puts "Polyphony backend: #{Thread.current.backend.kind}"

data/test/test_app.rb

@@ -122,7 +122,7 @@ class AppTest < Minitest::Test
     assert_equal Status::INTERNAL_SERVER_ERROR, req.response_status
   end
 
-  def test_automatic_redirect_on_trailing_slash    
+  def test_automatic_redirect_on_trailing_slash
     req = make_request(':method' => 'GET', ':path' => '/test/rss/')
     assert_equal Status::MOVED_PERMANENTLY, req.response_status
     assert_equal '/test/rss', req.response_headers['Location']

data/test/test_caching.rb

@@ -40,7 +40,7 @@ class CachingTest < Minitest::Test
     @app = Syntropy::App.new(**@env)
 
     @c_fd, @s_fd = make_socket_pair
-    @adapter = TP2::Connection.new(nil, @machine, @s_fd, @env) { @app.(it) }
+    @adapter = Syntropy::Connection.new(nil, @machine, @s_fd, @env) { @app.(it) }
   end
 
   def teardown