midori.rb 0.5.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f47091da1ed0c2aa5186718051d4c0f67cf691eb0c0cf579bbfeff0fa007e1e
-  data.tar.gz: 172665350943d2de1faae70882bfad72a799756edc3d993185ea6a6d0cb1661e
+  metadata.gz: 39f2783e703297e0c67b6190fe38776e92397215917bb1883da0fb7b8e218590
+  data.tar.gz: 8a150f94267e00f92e06ee41d3dd356eb03dc13349c940bf20146bfe008ebf69
 SHA512:
-  metadata.gz: 1a6801c29d82920d82cd25760ca929f3be55a402169d5518d34941409949e99e799e4a1170b267ccfe7707b66c00ace0b5b0674fffb1ebc3dfd842607a05025e
-  data.tar.gz: 6ee0eb8e0b7e496ca8c2a8f71e7d5e03d28172bd10839ae92e2ef01981076b3f9aba50d9ae1e7c1e6374b9b93c27fe8b63e1260de40eef8c67595f9dce45c7d2
+  metadata.gz: 9d2238695402c0b3cb064d52feadb6b71ef685dcc2b30f79cbdd7dd680de5d26bca3057abbb986bb611831c740f66e3ff7ee18bece2b675c51298012baa348a4
+  data.tar.gz: ecf3a5ae2f89baaa5215f1884ecfcd7972128e92f76f892c332f05b278be1d5fbc7a3862a8169a232025826df3e825636a55e09218ba7539bf44240a4494cd8a

data/example.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+$LOAD_PATH.unshift File.expand_path("./lib", __dir__)
+
+require 'evt'
+require 'midori'
+
+Fiber.set_scheduler Evt::Scheduler.new
+
+class HelloWorldAPI < Midori::API
+  get '/' do
+    'Ohayou Midori'
+  end
+end
+
+Fiber.schedule do
+  Midori::Runner.new(HelloWorldAPI).start
+end

data/example2.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+$LOAD_PATH.unshift File.expand_path("./lib", __dir__)
+
+require 'evt'
+require 'midori'
+require 'midori-contrib/redic'
+
+Fiber.set_scheduler Evt::Scheduler.new
+REDIS = Redic.new
+
+class HelloWorldAPI < Midori::API
+  get '/' do
+    REDIS.call 'GET', 'foo'
+  end
+end
+
+Fiber.schedule do
+  Midori::Runner.new(HelloWorldAPI).start
+end

data/ext/midori/websocket.c

@@ -1,32 +1,86 @@
 #include <ruby.h>
+#include <ruby/encoding.h>
 
 VALUE Midori = Qnil;
+VALUE MidoriException = Qnil;
 VALUE MidoriWebSocket = Qnil;
 
+VALUE ContinousFrameException = Qnil;
+VALUE OpCodeException = Qnil;
+VALUE NotMaskedException = Qnil;
+
 void Init_midori_ext();
-VALUE method_midori_websocket_mask(VALUE self, VALUE payload, VALUE mask);
+VALUE method_midori_websocket_decode(VALUE self, VALUE data);
 
-void Init_midori_ext() {
+void Init_midori_ext()
+{
   Midori = rb_define_module("Midori");
   MidoriWebSocket = rb_define_class_under(Midori, "WebSocket", rb_cObject);
-  rb_define_protected_method(MidoriWebSocket, "mask", method_midori_websocket_mask, 2);
+  MidoriException = rb_define_module_under(Midori, "Exception");
+  ContinousFrameException = rb_const_get(MidoriException, rb_intern("ContinuousFrame"));
+  OpCodeException = rb_const_get(MidoriException, rb_intern("OpCodeError"));
+  NotMaskedException = rb_const_get(MidoriException, rb_intern("NotMasked"));
+  rb_define_method(MidoriWebSocket, "decode", method_midori_websocket_decode, 1);
 }
 
-VALUE method_midori_websocket_mask(VALUE self, VALUE payload, VALUE mask) {
-  long n = RARRAY_LEN(payload), i, p, m;
-  VALUE unmasked = rb_ary_new2(n);
-
-  int mask_array[] = {
-    NUM2INT(rb_ary_entry(mask, 0)),
-    NUM2INT(rb_ary_entry(mask, 1)),
-    NUM2INT(rb_ary_entry(mask, 2)),
-    NUM2INT(rb_ary_entry(mask, 3))
-  };
-
-  for (i = 0; i < n; i++) {
-    p = NUM2INT(rb_ary_entry(payload, i));
-    m = mask_array[i % 4];
-    rb_ary_store(unmasked, i, INT2NUM(p ^ m));
+VALUE method_midori_websocket_decode(VALUE self, VALUE data)
+{
+  int byte, opcode, i, n, fin;
+  char *result;
+  int *mask_array;
+  ID getbyte = rb_intern("getbyte");
+  ID close = rb_intern("close");
+
+  byte = NUM2INT(rb_funcall(data, getbyte, 0));
+  fin = byte & 0x80;
+  opcode = byte & 0x0f;
+
+  if (fin != 0x80)
+    rb_raise(ContinousFrameException, "Continous Frame hasn't been implemented yet");
+
+  rb_iv_set(self, "@opcode", INT2NUM(opcode));
+  if (opcode != 0x1 && opcode != 0x2 && opcode != 0x8 && opcode != 0x9 && opcode != 0xA)
+    rb_raise(OpCodeException, "OpCode %d not supported", opcode);
+
+  if (opcode == 0x8)
+  {
+    rb_funcall(self, close, 0);
+  }
+
+  byte = NUM2INT(rb_funcall(data, getbyte, 0));
+  if ((byte & 0x80) != 0x80)
+  {
+    rb_raise(NotMaskedException, "Messages from client MUST be masked");
+  }
+
+  n = byte & 0x7f;
+  result = (char *)xmalloc(n);
+  mask_array = (int *)xmalloc(4);
+
+  for (i = 0; i < 4; i++) {
+    mask_array[i] = NUM2INT(rb_funcall(data, getbyte, 0));
+  }
+
+  for (i = 0; i < n; i++)
+  {
+    result[i] = NUM2INT(rb_funcall(data, getbyte, 0)) ^ mask_array[i % 4];
   }
-  return unmasked;
+
+  if (opcode == 0x1 || opcode == 0x9 || opcode == 0xA)
+  {
+    rb_iv_set(self, "@msg", rb_enc_str_new(result, n, rb_utf8_encoding()));
+  }
+  else
+  {
+    VALUE result_arr = rb_ary_new2(n);
+    for (i = 0; i < n; i++)
+    {
+      rb_ary_store(result_arr, i, INT2NUM(result[i]));
+    }
+    rb_iv_set(self, "@msg", result_arr);
+  }
+
+  xfree(mask_array);
+  xfree(result);
+  return Qnil;
 }

data/lib/midori.rb

@@ -1,20 +1,19 @@
 require 'cgi'
+require 'evt'
 require 'digest/sha1'
 require 'stringio'
 require 'fiber'
 require 'logger'
-require 'http/parser'
+require 'mizu'
 require 'mustermann'
-require 'murasaki'
 require 'socket'
 
-require_relative 'midori_ext'
 require_relative 'midori/core_ext/configurable'
 require_relative 'midori/core_ext/define_class'
 require_relative 'midori/core_ext/http_header'
 require_relative 'midori/core_ext/proc'
+require_relative 'midori/core_ext/socket'
 require_relative 'midori/core_ext/string'
-require_relative 'midori/core_ext/tcp_server'
 
 require_relative 'midori/version'
 
@@ -37,3 +36,4 @@ require_relative 'midori/configure'
 require_relative 'midori/runner'
 require_relative 'midori/logger'
 
+require_relative 'midori_ext'

data/lib/midori/configure.rb

@@ -4,7 +4,6 @@ class Midori::Configure
   extend Configurable
 
   set :logger, ::Logger.new(STDOUT)
-  set :protocol, :http
   set :bind, '127.0.0.1'
   set :port, 8080
   set :route_type, :sinatra
@@ -14,4 +13,8 @@ class Midori::Configure
   set :trusted_proxies, /\A127\.0\.0\.1\Z|\A(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\.|
                          \A::1\Z|\Afd[0-9a-f]{2}:.+|\Alocalhost\Z|\Aunix\Z|\Aunix:/ix
   set :tcp_fast_open, true
+  set :socket_reuse_port, false
+  set :keep_alive, true
+  set :keep_alive_timeout, 75
+  set :keep_alive_requests, 1000
 end

data/lib/midori/connection.rb

@@ -11,22 +11,18 @@ class Midori::Connection
   # @param [IO] socket raw socket
   def initialize(socket)
     @registered = false
-    @socket = socket
-    @monitor = nil
+    @socket = socket[0]
+    @peer_addr = socket[1].ip_unpack
     @close_flag = false
     @buffer = ''
-    listen(socket)
   end
 
   # Register events of connection
-  # @param [IO] socket raw socket
-  def listen(socket)
-    EventLoop.register(socket, :rw) do |monitor|
-      @monitor = monitor
-      if monitor.readable?
-        receive_data(monitor)
-      end
-      if monitor.writable?
+  # @param [Array] socket raw socket
+  def listen
+    Fiber.schedule do
+      until @socket.closed?
+        receive_data(@socket)
         if !@buffer.empty?
           send_buffer
         elsif @close_flag
@@ -45,27 +41,23 @@ class Midori::Connection
   end
 
   # Send buffer immediately
+  # @return [nil] nil
   private def send_buffer
-    if @monitor.writable?
-      written = @socket.write_nonblock(@buffer)
-      @buffer = @buffer.byteslice(written..-1)
-    end
+    @socket.write(@buffer) unless @socket.closed?
     nil
-  rescue IO::EAGAINWaitWritable => _e
-    # :nocov:
-    # Unknown Reason Resource Conflict
-    nil
-    # :nocov:
   end
 
   # Close the connection
+  # @return [nil] nil
   def close_connection
-    EventLoop.deregister @socket
     @socket.close
+    nil
   end
 
   # Close the connection after writing
+  # @return [nil] nil
   def close_connection_after_writing
     @close_flag = true
+    nil
   end
 end

data/lib/midori/core_ext/{tcp_server.rb → socket.rb}

@@ -1,9 +1,16 @@
-class TCPServer
+class Socket
   def tcp_fast_open
     # macOS devices option is DIFFERENT from Linux and FreeBSD
     opt = (/darwin/ =~ RUBY_PLATFORM) ? 1 : 5
     # Magic number 6 may refer to Socket::SOL_TCP or Socket::IPPROTO_TCP
-    self.setsockopt(6, Socket::TCP_FASTOPEN, opt)
+    setsockopt(6, Socket::TCP_FASTOPEN, opt)
+    true
+  rescue => _e
+    false
+  end
+
+  def reuse_port
+    setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1)
     true
   rescue => _e
     false

data/lib/midori/eventsource.rb

@@ -14,6 +14,7 @@ class Midori::EventSource
   # @param [String] data data to be sent
   def send(data)
     raise Midori::Exception::EventSourceTypeError unless data.is_a? String
+    # TODO: implement envents by standard
     @connection.send_data(data.split("\n").map {|str| "data: #{str}\n"}.join + "\n")
     @connection.close_connection_after_writing
   end

data/lib/midori/request.rb

@@ -26,15 +26,17 @@ class Midori::Request
     @body_parsed = false
     @is_websocket = false
     @is_eventsource = false
-    @parser = Http::Parser.new
+    @ip = ''
+    @port = 0
+    @parser = Mizu::Parser.new
     @params = {}
     @query_params = Hash.new(Array.new)
     @cookie = {}
     @body = ''
-    @parser.on_headers_complete = proc do
-      @protocol = @parser.http_version
-      @method = @parser.http_method
-      @path = @parser.request_url
+    @parser.on_complete do
+      @protocol = @parser.version
+      @method = @parser.method
+      @path = @parser.path
       # Turn header into case-insensitive due to RFC 2.6 Chapter 4.2
       # https://www.ietf.org/rfc/rfc2616.txt
       @parser.headers.each { |key, value| @header[key] = value }
@@ -50,10 +52,22 @@ class Midori::Request
       @path.gsub!(/\?(.*?)$/, '')
       @method = @method.to_sym
       @parsed = true
-      :stop
     end
   end
 
+  def reset!
+    @header = HTTPHeader.new
+    @parsed = false
+    @body_parsed = false
+    @is_websocket = false
+    @is_eventsource = false
+    @parser.reset!
+    @params = {}
+    @query_params = Hash.new(Array.new)
+    @cookie = {}
+    @body = ''
+  end
+
   # Init an request with String data
   # @param [String] data
   # @return [nil] nil
@@ -62,8 +76,9 @@ class Midori::Request
     if @parsed
       @body += data
     else
-      offset = @parser << data
-      @body += data[offset..-1] if @parsed
+      return nil if data.nil?
+      @parser << data
+      @body += data[@parser.offset..-1] if @parsed
     end
 
     # Set body parsed if body reaches content length

data/lib/midori/response.rb

@@ -21,7 +21,7 @@ class Midori::Response
   # Generate header string from hash
   # @return [String] generated string
   def generate_header
-    @header['Content-Length'] = @body.bytesize if @header['Content-Length'].nil? && !@body.empty?
+    @header['Content-Length'] = @body.bytesize if @header['Content-Length'].nil? && @header['Upgrade'].nil? && @header['Content-Type'] != 'text/event-stream'
     @header.map do |key, value|
       "#{key}: #{value}\r\n"
     end.join

data/lib/midori/runner.rb

@@ -28,25 +28,36 @@ class Midori::Runner
   # Start the Midori server
   # @note This is an async method, but no callback
   def start
-    return false if running? || EventLoop.running?
+    return false if running?
     @logger.info "Midori #{Midori::VERSION} is now running on #{bind}:#{port}".blue
-    @server = TCPServer.new(@bind, @port)
-    tfo = @server.tcp_fast_open if Midori::Configure.tcp_fast_open
-    @logger.warn 'Failed to use TCP Fast Open feature on your OS'.yellow unless tfo
-    async_fiber(Fiber.new do
+    init_socket
+    Fiber.schedule do
       @logger.info 'Midori is booting...'.blue
       @before.call
       @logger.info 'Midori is serving...'.blue
-      EventLoop.register(@server, :r) do |monitor|
-        socket = monitor.io.accept_nonblock
-        connection = Midori::Connection.new(socket)
-        connection.server_initialize(@api, @logger)
+      Fiber.schedule do
+        loop do
+          socket = @server.accept
+          connection = Midori::Connection.new(socket)
+          connection.server_initialize(@api, @logger)
+          connection.listen
+        end
       end
-    end)
-    EventLoop.start
+    end
     nil
   end
 
+  private def init_socket
+    @server = Socket.new Socket::AF_INET, Socket::SOCK_STREAM
+    @server.reuse_port if Midori::Configure.socket_reuse_port
+    @server.bind Addrinfo.tcp @bind, @port
+    @server.listen Socket::SOMAXCONN
+    if Midori::Configure.tcp_fast_open
+      tfo = @server.tcp_fast_open
+      @logger.warn 'Failed to use TCP Fast Open feature on your OS'.yellow unless tfo
+    end
+  end
+
   # Stop the Midori server
   # @note This is an async method, but no callback
   # @return [Boolean] [true] stop successfully
@@ -54,10 +65,8 @@ class Midori::Runner
   def stop
     if running?
       @logger.info 'Stopping Midori'.blue
-      EventLoop.deregister @server
       @server.close
       @server = nil
-      EventLoop.stop
       true
     else
       @logger.error 'Midori Server has NOT been started'.red

data/lib/midori/server.rb

@@ -17,40 +17,43 @@ module Midori::Server
   def server_initialize(api, logger)
     @api = api
     @logger = logger
+
     @request = Midori::Request.new
     @websocket = Midori::WebSocket.new(self)
     @eventsource = Midori::EventSource.new(self)
+
+    # Add keep-alive parameters
+    @keep_alive_timer = nil
+    @keep_alive_count = 1
   end
 
   # Logic of receiving data
-  # @param [String] monitor the socket able to read
-  def receive_data(monitor)
-    lambda do
-      async_fiber(Fiber.new do
-        begin
-          _sock_domain, remote_port, _remote_hostname, remote_ip = monitor.io.peeraddr
-          port, ip = remote_port, remote_ip
-          @request.ip = ip
-          @request.port = port
-          data = monitor.io.read_nonblock(16_384)
-          if @request.parsed? && @request.body_parsed?
-            websocket_request(StringIO.new(data))
-          else
-            @request.parse(data)
-            receive_new_request if @request.parsed && @request.body_parsed?
-          end
-        rescue EOFError, Errno::ENOTCONN => _e
-          close_connection
-          # Ignore client's disconnection
-        rescue => e
-          # :nocov:
-          # Leave for corner cases
-          close_connection
-          @logger.warn "#{@request.ip} - - #{e.class} #{e.backtrace.join("\n")}".yellow
-          # :nocov:
-        end
-      end)
-    end.call
+  # @param [Scoket] the socket able to read
+  def receive_data(socket)
+    begin
+      @request.ip, @request.port = @peer_addr
+      if @request.parsed? && !(@request.body_parsed?)
+        data = socket.read @request.body.bytesize - @request.header['Content-Length']
+      else
+        data = socket.readline
+      end
+
+      if @request.websocket?
+        websocket_request(StringIO.new(data))
+      else
+        @request.parse(data)
+        receive_new_request if @request.parsed? && @request.body_parsed?
+      end
+    rescue EOFError, Errno::ENOTCONN => _e
+      close_connection
+      # Ignore client's disconnection
+    rescue => e
+      # :nocov:
+      # Leave for corner cases
+      close_connection
+      @logger.warn "#{@request.ip} - - #{e.class} #{e.backtrace.join("\n")}".yellow
+      # :nocov:
+    end
   end
 
   # Logic of receiving new request
@@ -59,7 +62,7 @@ module Midori::Server
       start_time = Time.now
       @response = @api.receive(request, self)
       now_time = Time.now
-      @logger.info "#{@request.ip} - - \"#{@request.method} #{@request.path} HTTP/#{@request.protocol.join('.')}\" #{@response.status} #{sprintf("%.6f", now_time.to_f - start_time.to_f)}".green
+      @logger.info "#{@request.ip} - - \"#{@request.method} #{@request.path} HTTP/#{@request.protocol}\" #{@response.status} #{sprintf("%.6f", now_time.to_f - start_time.to_f)}".green
       call_event(:open) if @request.websocket?
     rescue Midori::Exception::NotFound => e
       @response = Midori::Sandbox.capture(e)
@@ -68,9 +71,10 @@ module Midori::Server
       @logger.error e.inspect.red
       @logger.warn e.backtrace.join("\n").yellow
     end
+
     unless @request.websocket? || @request.eventsource?
       send_data @response
-      close_connection_after_writing
+      proceed_keep_alive
     end
   end
 
@@ -109,4 +113,20 @@ module Midori::Server
   def call_event(event, args = [])
     -> { @websocket.instance_exec(*args, &@websocket.events[event]) }.call unless @websocket.events[event].nil?
   end
+
+  private def proceed_keep_alive
+    # Detect if it should close connection
+    if !Midori::Configure.keep_alive || (@keep_alive_count >= Midori::Configure.keep_alive_requests)
+      close_connection_after_writing
+      return
+    end
+    # Add timeout for keep-alive
+    @keep_alive_count += 1
+    Fiber.schedule do
+      sleep Midori::Configure.keep_alive_timeout
+      close_connection
+    end
+    # Reset request
+    @request.reset!
+  end
 end

data/lib/midori/version.rb

@@ -1,5 +1,5 @@
 # Midori Module
 module Midori
   # Current Version Code
-  VERSION = '0.5.4'.freeze
+  VERSION = '0.9.0'.freeze
 end

data/lib/midori/websocket.rb

@@ -15,40 +15,6 @@ class Midori::WebSocket
     @connection = connection
   end
 
-  # Decode raw data send from client
-  # @param [StringIO] data raw data
-  def decode(data)
-    # Fin and Opcode
-    byte_tmp = data.getbyte
-    fin = byte_tmp & 0b10000000
-    @opcode = byte_tmp & 0b00001111
-    # NOT Support Multiple Fragments
-    raise Midori::Exception::ContinuousFrame unless fin
-    raise Midori::Exception::OpCodeError unless [0x1, 0x2, 0x8, 0x9, 0xA].include? opcode
-    close if @opcode == 0x8 # Close Frame
-    # return if @opcode == 0x9 || @opcode == 0xA # Ping Pong
-    decode_mask(data)
-  end
-
-  # Decode masked message send from client
-  # @param [StringIO] data raw data
-  def decode_mask(data)
-    # Mask
-    byte_tmp = data.getbyte
-    is_masked = byte_tmp & 0b10000000
-    raise Midori::Exception::NotMasked unless is_masked == 128
-    # Payload
-    payload = byte_tmp & 0b01111111
-    mask = Array.new(4) { data.getbyte }
-    # Message
-    masked_msg = Array.new(payload) { data.getbyte }
-    @msg = self.mask(masked_msg, mask)
-    @msg = @msg.pack('C*').force_encoding('utf-8') if [0x1, 0x9, 0xA].include? opcode
-    # For debug
-    #  data.rewind
-    #  data.bytes {|byte| puts byte.to_s(16)}
-  end
-
   # API definition for events
   # @param [Symbol] event event name(open, message, close, ping, pong)
   # @yield what to do after event matched
@@ -66,11 +32,27 @@ class Midori::WebSocket
   # @param [Array<Integer>, String] msg data to send
   def send(msg)
     output = []
+    payload_length = []
+    if msg.size < 126
+      payload_length << msg.size
+    elsif msg.size < 65_536
+      payload_length << 126
+      payload_length.concat([msg.size].pack('n').unpack('C*'))
+    elsif msg.size < 2**63
+      payload_length << 127
+      payload_length.concat([msg.size >> 32, msg.size & 0xFFFFFFFF].pack('NN').unpack('C*'))
+    else
+      raise Midori::Exception::ContinuousFrame
+    end
+
     if msg.is_a?String
-      output << 0b10000001 << msg.size << msg
-      @connection.send_data(output.pack("CCA#{msg.size}"))
+      output << 0b10000001
+      output.concat payload_length
+      output.concat msg.unpack('C*')
+      @connection.send_data(output.pack('C*'))
     elsif msg.is_a? Array
-      output << 0b10000010 << msg.size
+      output << 0b10000010
+      output.concat payload_length
       output.concat msg
       @connection.send_data(output.pack('C*'))
     else

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: midori.rb
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.9.0
 platform: ruby
 authors:
 - HeckPsi Lab
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-06-28 00:00:00.000000000 Z
+date: 2020-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: murasaki
+  name: evt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: mustermann
   requirement: !ruby/object:Gem::Requirement
@@ -39,19 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: midori_http_parser
+  name: mizu
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.1
+        version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.1
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -78,6 +78,8 @@ files:
 - ".editorconfig"
 - ".github/ISSUE_TEMPLATE.md"
 - LICENSE
+- example.rb
+- example2.rb
 - ext/midori/extconf.rb
 - ext/midori/websocket.c
 - lib/midori.rb
@@ -91,8 +93,8 @@ files:
 - lib/midori/core_ext/define_class.rb
 - lib/midori/core_ext/http_header.rb
 - lib/midori/core_ext/proc.rb
+- lib/midori/core_ext/socket.rb
 - lib/midori/core_ext/string.rb
-- lib/midori/core_ext/tcp_server.rb
 - lib/midori/env.rb
 - lib/midori/eventsource.rb
 - lib/midori/exception.rb
@@ -125,16 +127,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.6
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.2.2
+signing_key:
 specification_version: 4
 summary: High performance ruby web framework
 test_files: []