tipi 0.30

data/lib/tipi/http2_stream.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'http/2'
+require_relative './request'
+
+module Tipi
+  # Manages an HTTP 2 stream
+  class HTTP2StreamHandler
+    attr_accessor :__next__
+    
+    def initialize(stream, &block)
+      @stream = stream
+      @connection_fiber = Fiber.current
+      @stream_fiber = spin { |req| handle_request(req, &block) }
+      
+      # Stream callbacks occur on the connection fiber (see HTTP2Adapter#each).
+      # The request handler is run on a separate fiber for each stream, allowing
+      # concurrent handling of incoming requests on the same HTTP/2 connection.
+      #
+      # The different stream adapter APIs suspend the stream fiber, waiting for
+      # stream callbacks to be called. The callbacks, in turn, transfer control to
+      # the stream fiber, effectively causing the return of the adapter API calls.
+      #
+      # Note: the request handler is run once headers are received. Reading the
+      # request body, if present, is at the discretion of the request handler.
+      # This mirrors the behaviour of the HTTP/1 adapter.
+      stream.on(:headers, &method(:on_headers))
+      stream.on(:data, &method(:on_data))
+      stream.on(:half_close, &method(:on_half_close))
+    end
+    
+    def handle_request(request, &block)
+      error = nil
+      block.(request)
+      @connection_fiber.schedule
+    rescue Polyphony::MoveOn
+      # ignore
+    rescue Exception => e
+      error = e
+    ensure
+      @done = true
+      @connection_fiber.schedule error
+    end
+    
+    def on_headers(headers)
+      @request = Request.new(headers.to_h, self)
+      @stream_fiber.schedule @request
+    end
+    
+    def on_data(data)
+      if @waiting_for_body_chunk
+        @waiting_for_body_chunk = nil
+        @stream_fiber.schedule data
+      else
+        @request.buffer_body_chunk(data)
+      end
+    end
+    
+    def on_half_close
+      if @waiting_for_body_chunk
+        @waiting_for_body_chunk = nil
+        @stream_fiber.schedule
+      elsif @waiting_for_half_close
+        @waiting_for_half_close = nil
+        @stream_fiber.schedule
+      else
+        @request.complete!
+      end
+    end
+    
+    def protocol
+      'h2'
+    end
+    
+    def get_body_chunk
+      # called in the context of the stream fiber
+      return nil if @request.complete?
+      
+      @waiting_for_body_chunk = true
+      # the chunk (or an exception) will be returned once the stream fiber is
+      # resumed
+      suspend
+    ensure
+      @waiting_for_body_chunk = nil
+    end
+    
+    # Wait for request to finish
+    def consume_request
+      return if @request.complete?
+      
+      @waiting_for_half_close = true
+      suspend
+    ensure
+      @waiting_for_half_close = nil
+    end
+    
+    # response API
+    def respond(chunk, headers)
+      headers[':status'] ||= '200'
+      @stream.headers(headers, end_stream: false)
+      @stream.data(chunk, end_stream: true)
+      @headers_sent = true
+    end
+    
+    def send_headers(headers, empty_response = false)
+      return if @headers_sent
+      
+      headers[':status'] ||= (empty_response ? 204 : 200).to_s
+      @stream.headers(headers, end_stream: false)
+      @headers_sent = true
+    end
+    
+    def send_chunk(chunk, done: false)
+      send_headers({}, false) unless @headers_sent
+      @stream.data(chunk, end_stream: done)
+    end
+    
+    def finish
+      if @headers_sent
+        @stream.close
+      else
+        headers[':status'] ||= '204'
+        @stream.headers(headers, end_stream: true)
+      end
+    end
+    
+    def stop
+      return if @done
+      
+      @stream.close
+      @stream_fiber.schedule(Polyphony::MoveOn.new)
+    end
+  end
+end

data/lib/tipi/rack_adapter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+module Tipi
+  module RackAdapter
+    # Implements a rack input stream:
+    # https://www.rubydoc.info/github/rack/rack/master/file/SPEC#label-The+Input+Stream
+    class InputStream
+      def initialize(request)
+        @request = request
+      end
+      
+      def gets; end
+      
+      def read(length = nil, outbuf = nil); end
+      
+      def each(&block)
+        @request.each_chunk(&block)
+      end
+      
+      def rewind; end
+    end
+    
+    class << self
+      def run(app)
+        ->(req) { respond(req, app.(env(req))) }
+      end
+      
+      def load(path)
+        src = IO.read(path)
+        instance_eval(src, path, 1)
+      end
+      
+      def env(request)
+        {
+          'REQUEST_METHOD'                 => request.method,
+          'SCRIPT_NAME'                    => '',
+          'PATH_INFO'                      => request.path,
+          'QUERY_STRING'                   => request.query_string || '',
+          'SERVER_NAME'                    => request.headers['Host'], # ?
+          'SERVER_PORT'                    => '80', # ?
+          'rack.version'                   => Rack::VERSION,
+          'rack.url_scheme'                => 'https', # ?
+          'rack.input'                     => InputStream.new(request),
+          'rack.errors'                    => STDERR, # ?
+          'rack.multithread'               => false,
+          'rack.run_once'                  => false,
+          'rack.hijack?'                   => false,
+          'rack.hijack'                    => nil,
+          'rack.hijack_io'                 => nil,
+          'rack.session'                   => nil,
+          'rack.logger'                    => nil,
+          'rack.multipart.buffer_size'     => nil,
+          'rack.multipar.tempfile_factory' => nil
+        }.tap do |env|
+          request.headers.each { |k, v| env["HTTP_#{k.upcase}"] = v }
+        end
+      end
+      
+      def respond(request, (status_code, headers, body))
+        headers[':status'] = status_code.to_s
+        request.respond(body.first, headers)
+      end
+    end
+  end
+end

data/lib/tipi/request.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Tipi
+  # HTTP request
+  class Request
+    attr_reader :headers, :adapter
+    attr_accessor :__next__
+    
+    def initialize(headers, adapter)
+      @headers  = headers
+      @adapter  = adapter
+    end
+    
+    def protocol
+      @protocol = @adapter.protocol
+    end
+    
+    def method
+      @method ||= @headers[':method']
+    end
+    
+    def scheme
+      @scheme ||= @headers[':scheme']
+    end
+    
+    def uri
+      @uri ||= URI.parse(@headers[':path'] || '')
+    end
+    
+    def path
+      @path ||= uri.path
+    end
+    
+    def query_string
+      @query_string ||= uri.query
+    end
+    
+    def query
+      return @query if @query
+      
+      @query = (q = uri.query) ? split_query_string(q) : {}
+    end
+    
+    def split_query_string(query)
+      query.split('&').each_with_object({}) do |kv, h|
+        k, v = kv.split('=')
+        h[k.to_sym] = URI.decode_www_form_component(v)
+      end
+    end
+    
+    def buffer_body_chunk(chunk)
+      @buffered_body_chunks ||= []
+      @buffered_body_chunks << chunk
+    end
+    
+    def each_chunk(&block)
+      if @buffered_body_chunks
+        @buffered_body_chunks.each(&block)
+        @buffered_body_chunks = nil
+      end
+      while !@message_complete && (chunk = @adapter.get_body_chunk)
+        yield chunk
+      end
+    end
+    
+    def complete!(keep_alive = nil)
+      @message_complete = true
+      @keep_alive = keep_alive
+    end
+    
+    def complete?
+      @message_complete
+    end
+    
+    def consume
+      @adapter.consume_request
+    end
+    
+    def keep_alive?
+      @keep_alive
+    end
+    
+    def read
+      buf = @buffered_body_chunks ? @buffered_body_chunks.join : +''
+      while (chunk = @adapter.get_body_chunk)
+        buf << chunk
+      end
+      buf
+    end
+    
+    def respond(body, headers = {})
+      @adapter.respond(body, headers)
+      @headers_sent = true
+    end
+    
+    def send_headers(headers = {}, empty_response = false)
+      return if @headers_sent
+      
+      @headers_sent = true
+      @adapter.send_headers(headers, empty_response: empty_response)
+    end
+    
+    def send_chunk(body, done: false)
+      send_headers({}) unless @headers_sent
+      
+      @adapter.send_chunk(body, done: done)
+    end
+    alias_method :<<, :send_chunk
+    
+    def finish
+      send_headers({}) unless @headers_sent
+      
+      @adapter.finish
+    end
+  end
+end

data/lib/tipi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tipi
+  VERSION = '0.30'
+end

data/lib/tipi/websocket.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+export :handler
+
+require 'digest/sha1'
+require 'websocket'
+
+module Tipi
+  # Websocket connection
+  class Websocket
+    def self.handler(&block)
+      proc { |client, header|
+        block.(new(client, header))
+      }
+    end  
+
+    def initialize(client, headers)
+      @client = client
+      @headers = headers
+      setup(headers)
+    end
+    
+    S_WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+    UPGRADE_RESPONSE = <<~HTTP.gsub("\n", "\r\n")
+    HTTP/1.1 101 Switching Protocols
+    Upgrade: websocket
+    Connection: Upgrade
+    Sec-WebSocket-Accept: %<accept>s
+    
+    HTTP
+    
+    def setup(headers)
+      key = headers['Sec-WebSocket-Key']
+      @version = headers['Sec-WebSocket-Version'].to_i
+      accept = Digest::SHA1.base64digest([key, S_WS_GUID].join)
+      @client << format(UPGRADE_RESPONSE, accept: accept)
+      
+      @reader = ::WebSocket::Frame::Incoming::Server.new(version: @version)
+    end
+    
+    def recv
+      loop do
+        data = @client.readpartial(8192)
+        break nil unless data
+        
+        @reader << data
+        if (msg = @reader.next)
+          break msg.to_s
+        end
+      end
+    end
+    
+    def send(data)
+      frame = ::WebSocket::Frame::Outgoing::Server.new(
+        version: @version, data: data, type: :text
+      )
+      @client << frame.to_s
+    end
+    alias_method :<<, :send
+  end
+end

data/test/coverage.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'coverage'
+require 'simplecov'
+
+class << SimpleCov::LinesClassifier
+  alias_method :orig_whitespace_line?, :whitespace_line?
+  def whitespace_line?(line)
+    line.strip =~ /^(begin|end|ensure|else|\})|(\s*rescue\s.+)$/ || orig_whitespace_line?(line)
+  end
+end
+
+module Coverage
+  EXCLUDE = %w{coverage eg helper run
+  }.map { |n| File.expand_path("test/#{n}.rb") }
+
+  LIB_FILES = Dir["#{File.join(FileUtils.pwd, 'lib')}/polyphony/**/*.rb"]
+
+  class << self
+    def relevant_lines_for_filename(filename)
+      @classifier ||= SimpleCov::LinesClassifier.new
+      @classifier.classify(IO.read(filename).lines)
+    end
+
+    def start
+      @result = {}
+      trace = TracePoint.new(:line) do |tp|
+        next if tp.path =~ /\(/
+      
+        absolute = File.expand_path(tp.path)
+        next unless LIB_FILES.include?(absolute)# =~ /^#{LIB_DIR}/
+        
+        @result[absolute] ||= relevant_lines_for_filename(absolute)
+        @result[absolute][tp.lineno - 1] = 1
+      end
+      trace.enable
+    end
+
+    def result
+      @result
+    end
+  end
+end
+
+SimpleCov.start

data/test/eg.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Kernel
+  RE_CONST  = /^[A-Z]/.freeze
+  RE_ATTR   = /^@(.+)$/.freeze
+
+  def eg(hash)
+    Module.new.tap do |m|
+      s = m.singleton_class
+      hash.each do |k, v|
+        case k
+        when RE_CONST
+          m.const_set(k, v)
+        when RE_ATTR
+          m.instance_variable_set(k, v)
+        else
+          block = if v.respond_to?(:to_proc)
+                    proc { |*args, &block| instance_exec { v.(*args, &block) } }
+                  else
+                    proc { v }
+                  end
+          s.define_method(k, &block)
+        end
+      end
+    end
+  end
+end