polyphony-http 0.26 → 0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76672787719c4ccfd1cd92917b206e11d512341aa2186f3e3c22089dfd1df440
-  data.tar.gz: c7ba3c2b3f61ed1626f299a8e5b142fca52a6beafed7aca3805ca7f1dfe42a8c
+  metadata.gz: 7d801a50af8ee9175a493eaacd5420e77e83b8afca771d68e3816e932ffd3ba4
+  data.tar.gz: aec82ce54ea3f047ef572c5b5bf624536ec06cb3eba4cde96b83d8a70835930b
 SHA512:
-  metadata.gz: 06fe3a7fa8eb7d265367269d8f4f4c92854e84c18de2ee301d73f0755f8c4b24ac6b04e332a2b5fabac7b4ff8e7776966800aae1574cd2b2c5b6b42d9866f5b3
-  data.tar.gz: 2912df5bf797b51bb25d83c4ce5bbe81823aa31a3536a2f76124e3d66801086519784f0ea8584e6cf8ea51343d3c5fb8b7b34d323199c3a79c694ae2bb4c833e
+  metadata.gz: 91addbdbae045ceb39459f7bc8699685a5c8269d413f87888c96982ba470525b9d43b58e79c7600394eb0ba3b195948ebe9dc9162ffcea2e4f22c13d08fe1aee
+  data.tar.gz: 6ba0bd3b38b22d1925c3b43d869646ba8173acaf999d4df84b47c69b093f04071cd91f159c454e6a23389f6e2ddee60b9005e85d4d5b8d33c6b887da7f3ec658

data/.github/workflows/test.yml

@@ -0,0 +1,18 @@
+name: Tests
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.6.5
+    - name: Install dependencies
+      run: |
+        gem install bundler
+        bundle install
+    - name: Run tests
+      run:  bundle exec rake test

data/CHANGELOG.md

@@ -1,6 +1,10 @@
+## 0.27 2020-04-14
+
+* Remove modulation dependency
+
 ## 0.26 2020-03-03
 
-* Fix "Server#listen"
+* Fix `Server#listen`
 
 ## 0.25 2020-02-19
 

data/Gemfile.lock

@@ -1,11 +1,10 @@
 PATH
   remote: .
   specs:
-    polyphony-http (0.26)
+    polyphony-http (0.27)
       http-2 (~> 0.10.0)
       http_parser.rb (~> 0.6.0)
-      modulation (~> 1.0)
-      polyphony (~> 0.32)
+      polyphony (~> 0.38)
       rack (~> 2.0.8)
       websocket (~> 1.2.8)
 
@@ -25,10 +24,9 @@ GEM
       builder
       minitest (>= 5.0)
       ruby-progressbar
-    modulation (1.0)
-    polyphony (0.32)
-      modulation (~> 1.0)
+    polyphony (0.38)
     rack (2.0.9)
+    rake (12.3.3)
     ruby-progressbar (1.10.1)
     simplecov (0.17.1)
       docile (~> 1.1)
@@ -45,7 +43,8 @@ DEPENDENCIES
   minitest (~> 5.11.3)
   minitest-reporters (~> 1.4.2)
   polyphony-http!
+  rake (~> 12.3.3)
   simplecov (~> 0.17.1)
 
 BUNDLED WITH
-   2.1.3
+   2.1.4

data/lib/polyphony/http/server.rb

@@ -1,51 +1,56 @@
 # frozen_string_literal: true
 
-export :serve, :listen, :accept_loop, :client_loop
-
-Net   = Polyphony::Net
-HTTP1 = import('./server/http1')
-HTTP2 = import('./server/http2')
-
-ALPN_PROTOCOLS = %w[h2 http/1.1].freeze
-H2_PROTOCOL = 'h2'
-
-def serve(host, port, opts = {}, &handler)
-  opts[:alpn_protocols] = ALPN_PROTOCOLS
-  server = Net.tcp_listen(host, port, opts)
-  accept_loop(server, opts, &handler)
-ensure
-  server.close
-end
-
-def listen(host, port, opts = {})
-  opts[:alpn_protocols] = ALPN_PROTOCOLS
-  Net.tcp_listen(host, port, opts).tap do |socket|
-    socket.define_singleton_method(:each) do |&block|
-      MODULE.accept_loop(socket, opts, &block)
+require_relative './server/http1'
+require_relative './server/http2'
+
+module Polyphony
+  module HTTP
+    module Server
+      ALPN_PROTOCOLS = %w[h2 http/1.1].freeze
+      H2_PROTOCOL = 'h2'
+      
+      class << self
+        def serve(host, port, opts = {}, &handler)
+          opts[:alpn_protocols] = ALPN_PROTOCOLS
+          server = Net.tcp_listen(host, port, opts)
+          accept_loop(server, opts, &handler)
+        ensure
+          server.close
+        end
+        
+        def listen(host, port, opts = {})
+          opts[:alpn_protocols] = ALPN_PROTOCOLS
+          Net.tcp_listen(host, port, opts).tap do |socket|
+            socket.define_singleton_method(:each) do |&block|
+              ::Polyphony::HTTP::Server.accept_loop(socket, opts, &block)
+            end
+          end
+        end
+        
+        def accept_loop(server, opts, &handler)
+          loop do
+            client = server.accept
+            spin { client_loop(client, opts, &handler) }
+          rescue OpenSSL::SSL::SSLError
+            # disregard
+          end
+        end
+        
+        def client_loop(client, opts, &handler)
+          client.no_delay if client.respond_to?(:no_delay)
+          adapter = protocol_adapter(client, opts)
+          adapter.each(&handler)
+        ensure
+          client.close
+        end
+        
+        def protocol_adapter(socket, opts)
+          use_http2 = socket.respond_to?(:alpn_protocol) &&
+                      socket.alpn_protocol == H2_PROTOCOL
+          klass = use_http2 ? HTTP2Adapter : HTTP1Adapter
+          klass.new(socket, opts)
+        end
+      end
     end
   end
 end
-
-def accept_loop(server, opts, &handler)
-  loop do
-    client = server.accept
-    spin { client_loop(client, opts, &handler) }
-  rescue OpenSSL::SSL::SSLError
-    # disregard
-  end
-end
-
-def client_loop(client, opts, &handler)
-  client.no_delay if client.respond_to?(:no_delay)
-  adapter = protocol_adapter(client, opts)
-  adapter.each(&handler)
-ensure
-  client.close
-end
-
-def protocol_adapter(socket, opts)
-  use_http2 = socket.respond_to?(:alpn_protocol) &&
-              socket.alpn_protocol == H2_PROTOCOL
-  klass = use_http2 ? HTTP2 : HTTP1
-  klass.new(socket, opts)
-end

data/lib/polyphony/http/server/http1.rb

@@ -1,267 +1,270 @@
 # frozen_string_literal: true
 
-export_default :HTTP1Adapter
-
 require 'http/parser'
-
-Request = import('./request')
-HTTP2 = import('./http2')
-
-# HTTP1 protocol implementation
-class HTTP1Adapter
-  # Initializes a protocol adapter instance
-  def initialize(conn, opts)
-    @conn = conn
-    @opts = opts
-    @parser = HTTP::Parser.new(self)
-  end
-
-  def each(&block)
-    while (data = @conn.readpartial(8192))
-      return if handle_incoming_data(data, &block)
-    end
-  rescue SystemCallError, IOError
-    # ignore
-  ensure
-    finalize_client_loop
-  end
-
-  # return [Boolean] true if client loop should stop
-  def handle_incoming_data(data, &block)
-    @parser << data
-    snooze
-    while (request = @requests_head)
-      return true if upgrade_connection(request.headers, &block)
-
-      @requests_head = request.__next__
-      block.call(request)
-      return true unless request.keep_alive?
-    end
-    nil
-  end
-
-  def finalize_client_loop
-    # release references to various objects
-    @requests_head = @requests_tail = nil
-    @parser = nil
-    @conn.close
-  end
-
-  # Reads a body chunk for the current request. Transfers control to the parse
-  # loop, and resumes once the parse_loop has fired the on_body callback
-  def get_body_chunk
-    @waiting_for_body_chunk = true
-    @next_chunk = nil
-    while !@requests_tail.complete? && (data = @conn.readpartial(8192))
-      @parser << data
-      return @next_chunk if @next_chunk
-
-      snooze
-    end
-    nil
-  ensure
-    @waiting_for_body_chunk = nil
-  end
-
-  # Waits for the current request to complete. Transfers control to the parse
-  # loop, and resumes once the parse_loop has fired the on_message_complete
-  # callback
-  def consume_request
-    request = @requests_head
-    while (data = @conn.readpartial(8192))
-      @parser << data
-      return if request.complete?
-
-      snooze
-    end
-  end
-
-  def protocol
-    version = @parser.http_version
-    "HTTP #{version.join('.')}"
-  end
-
-  def on_headers_complete(headers)
-    headers[':path'] = @parser.request_url
-    headers[':method'] = @parser.http_method
-    queue_request(Request.new(headers, self))
-  end
-
-  def queue_request(request)
-    if @requests_head
-      @requests_tail.__next__ = request
-      @requests_tail = request
-    else
-      @requests_head = @requests_tail = request
-    end
-  end
-
-  def on_body(chunk)
-    if @waiting_for_body_chunk
-      @next_chunk = chunk
-      @waiting_for_body_chunk = nil
-    else
-      @requests_tail.buffer_body_chunk(chunk)
-    end
-  end
-
-  def on_message_complete
-    @waiting_for_body_chunk = nil
-    @requests_tail.complete!(@parser.keep_alive?)
-  end
-
-  # Upgrades the connection to a different protocol, if the 'Upgrade' header is
-  # given. By default the only supported upgrade protocol is HTTP2. Additional
-  # protocols, notably WebSocket, can be specified by passing a hash to the
-  # :upgrade option when starting a server:
-  #
-  #     opts = {
-  #       upgrade: {
-  #         websocket: Polyphony::Websocket.handler(&method(:ws_handler))
-  #       }
-  #     }
-  #     Polyphony::HTTP::Server.serve('0.0.0.0', 1234, opts) { |req| ... }
-  #
-  # @param headers [Hash] request headers
-  # @return [boolean] truthy if the connection has been upgraded
-  def upgrade_connection(headers, &block)
-    upgrade_protocol = headers['Upgrade']
-    return nil unless upgrade_protocol
-
-    upgrade_protocol = upgrade_protocol.downcase.to_sym
-    upgrade_handler = @opts[:upgrade] && @opts[:upgrade][upgrade_protocol]
-    return upgrade_with_handler(upgrade_handler, headers) if upgrade_handler
-    return upgrade_to_http2(headers, &block) if upgrade_protocol == :h2c
-
-    nil
-  end
-
-  def upgrade_with_handler(handler, headers)
-    @parser = @requests_head = @requests_tail = nil
-    handler.(@conn, headers)
-    true
-  end
-
-  def upgrade_to_http2(headers, &block)
-    @parser = @requests_head = @requests_tail = nil
-    HTTP2.upgrade_each(@conn, @opts, http2_upgraded_headers(headers), &block)
-    true
-  end
-
-  # Returns headers for HTTP2 upgrade
-  # @param headers [Hash] request headers
-  # @return [Hash] headers for HTTP2 upgrade
-  def http2_upgraded_headers(headers)
-    headers.merge(
-      ':scheme'    => 'http',
-      ':authority' => headers['Host']
-    )
-  end
-
-  # response API
-
-  # Sends response including headers and body. Waits for the request to complete
-  # if not yet completed. The body is sent using chunked transfer encoding.
-  # @param body [String] response body
-  # @param headers
-  def respond(body, headers)
-    consume_request if @parsing
-    data = format_headers(headers, body)
-    if body
-      data << if @parser.http_minor == 0
-                body
-              else
-                "#{body.bytesize.to_s(16)}\r\n#{body}\r\n0\r\n\r\n"
-              end
-    end
-    @conn << data
-  end
-
-  DEFAULT_HEADERS_OPTS = {
-    empty_response:  false,
-    consume_request: true
-  }.freeze
-
-  # Sends response headers. If empty_response is truthy, the response status
-  # code will default to 204, otherwise to 200.
-  # @param headers [Hash] response headers
-  # @param empty_response [boolean] whether a response body will be sent
-  # @return [void]
-  def send_headers(headers, opts = DEFAULT_HEADERS_OPTS)
-    @conn << format_headers(headers, !opts[:empty_response])
-  end
-
-  # Sends a response body chunk. If no headers were sent, default headers are
-  # sent using #send_headers. if the done option is true(thy), an empty chunk
-  # will be sent to signal response completion to the client.
-  # @param chunk [String] response body chunk
-  # @param done [boolean] whether the response is completed
-  # @return [void]
-  def send_chunk(chunk, done: false)
-    data = +"#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
-    data << "0\r\n\r\n" if done
-    @conn << data
-  end
-
-  # Finishes the response to the current request. If no headers were sent,
-  # default headers are sent using #send_headers.
-  # @return [void]
-  def finish
-    @conn << "0\r\n\r\n"
-  end
-
-  def close
-    @conn.close
-  end
-
-  private
-
-  # Formats response headers. If empty_response is true(thy), the response
-  # status code will default to 204, otherwise to 200.
-  # @param headers [Hash] response headers
-  # @param empty_response [boolean] whether a response body will be sent
-  # @return [String] formatted response headers
-  def format_headers(headers, body)
-    status = headers[':status'] || (body ? 200 : 204)
-    data = format_status_line(body, status)
-
-    headers.each do |k, v|
-      next if k =~ /^:/
-
-      format_header_lines(k, v)
-    end
-    data << "\r\n"
-  end
-
-  def format_header_lines(key, value)
-    if value.is_a?(Array)
-      value.inject(+'') { |data, item| data << "#{key}: #{item}\r\n" }
-    else
-      "#{key}: #{value}\r\n"
-    end
-  end
-
-  def format_status_line(body, status)
-    if !body
-      empty_status_line(status)
-    else
-      with_body_status_line(status, body)
-    end
-  end
-
-  def empty_status_line(status)
-    if status == 204
-      +"HTTP/1.1 #{status}\r\n"
-    else
-      +"HTTP/1.1 #{status}\r\nContent-Length: 0\r\n"
-    end
-  end
-
-  def with_body_status_line(status, body)
-    if @parser.http_minor == 0
-      +"HTTP/1.0 #{status}\r\nContent-Length: #{body.bytesize}\r\n"
-    else
-      +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
+require_relative './request'
+require_relative './http2'
+
+module Polyphony
+  module HTTP
+    module Server
+      # HTTP1 protocol implementation
+      class HTTP1Adapter
+        # Initializes a protocol adapter instance
+        def initialize(conn, opts)
+          @conn = conn
+          @opts = opts
+          @parser = ::HTTP::Parser.new(self)
+        end
+
+        def each(&block)
+          while (data = @conn.readpartial(8192))
+            return if handle_incoming_data(data, &block)
+          end
+        rescue SystemCallError, IOError
+          # ignore
+        ensure
+          finalize_client_loop
+        end
+
+        # return [Boolean] true if client loop should stop
+        def handle_incoming_data(data, &block)
+          @parser << data
+          snooze
+          while (request = @requests_head)
+            return true if upgrade_connection(request.headers, &block)
+
+            @requests_head = request.__next__
+            block.call(request)
+            return true unless request.keep_alive?
+          end
+          nil
+        end
+
+        def finalize_client_loop
+          # release references to various objects
+          @requests_head = @requests_tail = nil
+          @parser = nil
+          @conn.close
+        end
+
+        # Reads a body chunk for the current request. Transfers control to the parse
+        # loop, and resumes once the parse_loop has fired the on_body callback
+        def get_body_chunk
+          @waiting_for_body_chunk = true
+          @next_chunk = nil
+          while !@requests_tail.complete? && (data = @conn.readpartial(8192))
+            @parser << data
+            return @next_chunk if @next_chunk
+
+            snooze
+          end
+          nil
+        ensure
+          @waiting_for_body_chunk = nil
+        end
+
+        # Waits for the current request to complete. Transfers control to the parse
+        # loop, and resumes once the parse_loop has fired the on_message_complete
+        # callback
+        def consume_request
+          request = @requests_head
+          while (data = @conn.readpartial(8192))
+            @parser << data
+            return if request.complete?
+
+            snooze
+          end
+        end
+
+        def protocol
+          version = @parser.http_version
+          "HTTP #{version.join('.')}"
+        end
+
+        def on_headers_complete(headers)
+          headers[':path'] = @parser.request_url
+          headers[':method'] = @parser.http_method
+          queue_request(Request.new(headers, self))
+        end
+
+        def queue_request(request)
+          if @requests_head
+            @requests_tail.__next__ = request
+            @requests_tail = request
+          else
+            @requests_head = @requests_tail = request
+          end
+        end
+
+        def on_body(chunk)
+          if @waiting_for_body_chunk
+            @next_chunk = chunk
+            @waiting_for_body_chunk = nil
+          else
+            @requests_tail.buffer_body_chunk(chunk)
+          end
+        end
+
+        def on_message_complete
+          @waiting_for_body_chunk = nil
+          @requests_tail.complete!(@parser.keep_alive?)
+        end
+
+        # Upgrades the connection to a different protocol, if the 'Upgrade' header is
+        # given. By default the only supported upgrade protocol is HTTP2. Additional
+        # protocols, notably WebSocket, can be specified by passing a hash to the
+        # :upgrade option when starting a server:
+        #
+        #     opts = {
+        #       upgrade: {
+        #         websocket: Polyphony::Websocket.handler(&method(:ws_handler))
+        #       }
+        #     }
+        #     Polyphony::HTTP::Server.serve('0.0.0.0', 1234, opts) { |req| ... }
+        #
+        # @param headers [Hash] request headers
+        # @return [boolean] truthy if the connection has been upgraded
+        def upgrade_connection(headers, &block)
+          upgrade_protocol = headers['Upgrade']
+          return nil unless upgrade_protocol
+
+          upgrade_protocol = upgrade_protocol.downcase.to_sym
+          upgrade_handler = @opts[:upgrade] && @opts[:upgrade][upgrade_protocol]
+          return upgrade_with_handler(upgrade_handler, headers) if upgrade_handler
+          return upgrade_to_http2(headers, &block) if upgrade_protocol == :h2c
+
+          nil
+        end
+
+        def upgrade_with_handler(handler, headers)
+          @parser = @requests_head = @requests_tail = nil
+          handler.(@conn, headers)
+          true
+        end
+
+        def upgrade_to_http2(headers, &block)
+          @parser = @requests_head = @requests_tail = nil
+          HTTP2Adapter.upgrade_each(@conn, @opts, http2_upgraded_headers(headers), &block)
+          true
+        end
+
+        # Returns headers for HTTP2 upgrade
+        # @param headers [Hash] request headers
+        # @return [Hash] headers for HTTP2 upgrade
+        def http2_upgraded_headers(headers)
+          headers.merge(
+            ':scheme'    => 'http',
+            ':authority' => headers['Host']
+          )
+        end
+
+        # response API
+
+        # Sends response including headers and body. Waits for the request to complete
+        # if not yet completed. The body is sent using chunked transfer encoding.
+        # @param body [String] response body
+        # @param headers
+        def respond(body, headers)
+          consume_request if @parsing
+          data = format_headers(headers, body)
+          if body
+            data << if @parser.http_minor == 0
+                      body
+                    else
+                      "#{body.bytesize.to_s(16)}\r\n#{body}\r\n0\r\n\r\n"
+                    end
+          end
+          @conn << data
+        end
+
+        DEFAULT_HEADERS_OPTS = {
+          empty_response:  false,
+          consume_request: true
+        }.freeze
+
+        # Sends response headers. If empty_response is truthy, the response status
+        # code will default to 204, otherwise to 200.
+        # @param headers [Hash] response headers
+        # @param empty_response [boolean] whether a response body will be sent
+        # @return [void]
+        def send_headers(headers, opts = DEFAULT_HEADERS_OPTS)
+          @conn << format_headers(headers, !opts[:empty_response])
+        end
+
+        # Sends a response body chunk. If no headers were sent, default headers are
+        # sent using #send_headers. if the done option is true(thy), an empty chunk
+        # will be sent to signal response completion to the client.
+        # @param chunk [String] response body chunk
+        # @param done [boolean] whether the response is completed
+        # @return [void]
+        def send_chunk(chunk, done: false)
+          data = +"#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
+          data << "0\r\n\r\n" if done
+          @conn << data
+        end
+
+        # Finishes the response to the current request. If no headers were sent,
+        # default headers are sent using #send_headers.
+        # @return [void]
+        def finish
+          @conn << "0\r\n\r\n"
+        end
+
+        def close
+          @conn.close
+        end
+
+        private
+
+        # Formats response headers. If empty_response is true(thy), the response
+        # status code will default to 204, otherwise to 200.
+        # @param headers [Hash] response headers
+        # @param empty_response [boolean] whether a response body will be sent
+        # @return [String] formatted response headers
+        def format_headers(headers, body)
+          status = headers[':status'] || (body ? 200 : 204)
+          data = format_status_line(body, status)
+
+          headers.each do |k, v|
+            next if k =~ /^:/
+
+            format_header_lines(k, v)
+          end
+          data << "\r\n"
+        end
+
+        def format_header_lines(key, value)
+          if value.is_a?(Array)
+            value.inject(+'') { |data, item| data << "#{key}: #{item}\r\n" }
+          else
+            "#{key}: #{value}\r\n"
+          end
+        end
+
+        def format_status_line(body, status)
+          if !body
+            empty_status_line(status)
+          else
+            with_body_status_line(status, body)
+          end
+        end
+
+        def empty_status_line(status)
+          if status == 204
+            +"HTTP/1.1 #{status}\r\n"
+          else
+            +"HTTP/1.1 #{status}\r\nContent-Length: 0\r\n"
+          end
+        end
+
+        def with_body_status_line(status, body)
+          if @parser.http_minor == 0
+            +"HTTP/1.0 #{status}\r\nContent-Length: #{body.bytesize}\r\n"
+          else
+            +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
+          end
+        end
+      end
     end
   end
 end