ruby_wolf 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14d13bd7de3c5cca903738aefbe18c1d9e512a49
+  data.tar.gz: e92866e154a80c358571348ebedbcc3fa7c0038b
+SHA512:
+  metadata.gz: 18c7b7288ab955e023beaf8de4a58fd763d68712fbe1b3589280b8c9899ee621a20bab20d1c6c666644597d1522428958a4397b373175c50a37586cf75ebb55b
+  data.tar.gz: 238eadfe11529cae062586465abf71ec3b72df78d4f5cf24a8822265663158c9d2e67d4b132c6682643a7b4309e536d1ff1d61194432809ca80602d84ec61b08

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.13.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at nguyenquangminh0711@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby_wolf.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Nguyễn Quang Minh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+# RubyWolf
+
+Ruby wolf is a tiny ruby web server for rack-based application. This server follows pre-forked and event driven with kqueue / epoll approach. Honestly, this web server is written for study and research purpose. I'm sure it could be used anywhere. So, don't use it in real world :)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ruby_wolf'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby_wolf
+
+## Usage
+
+Start your rack-based application with the following command:
+
+`ruby_wolf -p 3000`
+
+To explore the provided options, please use `ruby_wolf --help`
+
+## Benchmark
+
+Benchmark with some Hello world application:
+
+### RubyWolf
+
+```
+  50%      7
+  66%     11
+  75%     14
+  80%     15
+  90%     19
+  95%     24
+  98%     31
+  99%     33
+ 100%     51 (longest request)
+```
+
+### Puma
+
+```
+  50%     25
+  66%     27
+  75%     28
+  80%     29
+  90%     31
+  95%     32
+  98%     35
+  99%     37
+ 100%     39 (longest request)
+```
+
+### Thin
+
+```
+  50%     22
+  66%     23
+  75%     24
+  80%     24
+  90%     28
+  95%     30
+  98%     34
+  99%     36
+ 100%    227 (longest request)
+```
+
+Note that Hello world application is not considered to be a real application. Thus this benchmark doesn't mean much
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/ruby_wolf

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+#
+# Copyright (c) 2017 Nguyễn Quang Minh
+#
+
+require 'ruby_wolf'
+
+cli = RubyWolf::CLI.new ARGV
+
+cli.run

data/lib/ruby_wolf/cli.rb

@@ -0,0 +1,56 @@
+require 'optparse'
+
+module RubyWolf
+  class CLI
+    attr_reader :app, :server, :configs
+
+    def initialize(args)
+      @args = args
+      @configs = RubyWolf::Configuration.new
+      @app_root = `pwd`.to_s.strip
+    end
+
+    def run
+      parse_options
+      raise 'Rack file not found' unless File.exist?(rack_file)
+
+      @server = RubyWolf::Server.new(rack_file, configs)
+      @server.start
+    end
+
+    def parse_options
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: ruby_wolf [options]'
+
+        opts.on('-d', '--daemon', 'Demonize this web server to run background') do
+          @configs[:daemon] = true
+        end
+
+        opts.on('-h HOST', '--port=HOST', 'Binding host') do |arg|
+          @configs[:host] = arg
+        end
+
+        opts.on('-p PORT', '--port=PORT', 'Port of the program') do |arg|
+          @configs[:port] = arg.to_i
+        end
+
+        opts.on('-w WORKER', '--worker=WORKER', 'Number of worker processes') do |arg|
+          @configs[:worker] = arg.to_i
+        end
+
+        opts.on('-h', '--help', 'Show the usages') do
+          puts opts
+          exit
+        end
+      end
+
+      opt_parser.parse!(@args)
+    end
+
+    private
+
+    def rack_file
+      "#{@app_root}/config.ru"
+    end
+  end
+end

data/lib/ruby_wolf/configuration.rb

@@ -0,0 +1,25 @@
+module RubyWolf
+  class Configuration < BasicObject
+    DEFAULT_DAEMON = false
+    DEFAULT_HOST = '0.0.0.0'.freeze
+    DEFAULT_PORT = 3000
+    DEFAULT_WORKER = 4
+
+    def initialize
+      @configs = {
+        daemon: DEFAULT_DAEMON,
+        worker: DEFAULT_WORKER,
+        host: DEFAULT_HOST,
+        port: DEFAULT_PORT
+      }
+    end
+
+    def []=(key, value)
+      @configs[key] = value
+    end
+
+    def [](key)
+      @configs[key]
+    end
+  end
+end

data/lib/ruby_wolf/connection.rb

@@ -0,0 +1,45 @@
+module RubyWolf
+  class Connection
+    attr_reader :socket, :read_data, :write_data
+
+    def initialize(socket)
+      @socket = socket
+      @read_data = ''
+      @write_data = ''
+
+      @reading = true
+    end
+
+    def need_to_read?
+      @reading
+    end
+
+    def read
+      @read_data << socket.read_nonblock(RubyWolf::READ_SIZE)
+      @reading = false if @read_data.end_with?(RubyWolf::CRLF)
+    rescue EOFError
+      @reading = false
+    end
+
+    def enqueue_write(data)
+      @write_data += data
+    end
+
+    def write
+      writen = socket.write_nonblock(@write_data)
+      @write_data[0..writen] = ''
+    end
+
+    def need_to_write?
+      !@write_data.length.zero?
+    end
+
+    def to_io
+      @socket
+    end
+
+    def close
+      @socket.close
+    end
+  end
+end

data/lib/ruby_wolf/handler.rb

@@ -0,0 +1,84 @@
+require 'http/parser'
+
+module RubyWolf
+  class Handler
+
+    attr_reader :app, :env, :connection, :response, :callback
+
+    def initialize(app, connection, &callback)
+      @app = app
+      @connection = connection
+      @callback = callback
+      @env = {}
+      @response = ''
+    end
+
+    def process
+      prepare_rack_env
+      parse_request
+      generate_response
+      callback.call(response) if callback
+      response
+    end
+
+    private
+
+    def prepare_rack_env
+      @env = ENV.to_h
+      @env.delete 'HTTP_CONTENT_LENGTH'
+      url_scheme = %w(yes on 1).include?(ENV[::Rack::HTTPS]) ? 'https' : 'http'
+      @env.update(
+        ::Rack::RACK_VERSION      => ::Rack::VERSION,
+        ::Rack::RACK_INPUT        => STDIN,
+        ::Rack::RACK_ERRORS       => STDERR,
+        ::Rack::RACK_MULTITHREAD  => false,
+        ::Rack::RACK_MULTIPROCESS => true,
+        ::Rack::RACK_RUNONCE      => true,
+        ::Rack::RACK_URL_SCHEME   => url_scheme,
+        ::Rack::SERVER_PROTOCOL   => 'HTTP/1.1'
+      )
+    end
+
+    def parse_request
+      parser = Http::Parser.new
+      parser.on_headers_complete = proc do
+        env[::Rack::HTTP_VERSION] = parser.http_version
+        env[::Rack::REQUEST_METHOD] = parser.http_method
+
+        uri = URI.parse(parser.request_url)
+        env[::Rack::REQUEST_PATH] = uri.path
+        env[::Rack::QUERY_STRING] = uri.query
+      end
+      parser << connection.read_data
+      RubyWolf.log(
+        [
+          "HTTP/#{env[::Rack::HTTP_VERSION].join('.')}",
+          env[::Rack::REQUEST_METHOD],
+          "#{env[::Rack::REQUEST_PATH]}?#{env[::Rack::QUERY_STRING]}"
+        ].join(' ')
+      )
+    end
+
+    def generate_response
+      status, headers, body = app.call(env)
+      RubyWolf.log(
+        "Response #{env[::Rack::SERVER_PROTOCOL]} #{status}"
+      )
+      compose_response(status, headers, body)
+    end
+
+    def compose_response(status, headers, body)
+      @response += "#{env[::Rack::SERVER_PROTOCOL]} #{status} #{RubyWolf::CRLF}"
+      headers.each do |key, value|
+        @response += "#{key}: #{value}#{RubyWolf::CRLF}"
+      end
+
+      @response += RubyWolf::CRLF
+      body.each do |part|
+        @response += part
+      end
+    ensure
+      body.close if body.respond_to? :close
+    end
+  end
+end

data/lib/ruby_wolf/server.rb

@@ -0,0 +1,79 @@
+require 'logger'
+
+module RubyWolf
+  class Server
+    attr_reader :app, :configs, :socket, :workers
+
+    def initialize(rack_file, configs)
+      @rack_file = rack_file
+      @configs = configs
+      @workers = []
+    end
+
+    def start
+      trap_signal
+      setup_rack
+      setup_socket
+      configs[:worker].times do
+        workers << RubyWolf::Worker.new(self)
+      end
+      Process.detach if configs[:daemon]
+      workers.each(&:start)
+      handle_loop
+    end
+
+    private
+
+    def setup_rack
+      RubyWolf.log('~~~ Ruby Wolf ~~~')
+      RubyWolf.log('Loading Rack application')
+      @app, _rack_options = ::Rack::Builder.parse_file(@rack_file)
+    end
+
+    def setup_socket
+      @socket = TCPServer.new(configs[:host], configs[:port])
+      RubyWolf.log("Server is running on #{configs[:host]}:#{configs[:port]}")
+      RubyWolf.log("Process pid is #{Process.pid}")
+      RubyWolf.log("Number of worker: #{configs[:worker]}")
+    end
+
+    def handle_loop
+      while stopped_pid = Process.wait do
+        stopped_worker = workers.find { |w| w.pid == stopped_pid }
+        next unless stopped_worker
+
+        RubyWolf.log("Worker with pid #{stopped_pid} suddenly stopped", :error)
+
+        sleep(1)
+        worker = RubyWolf::Worker.new(self)
+        worker.start
+
+        workers << worker
+      end
+    end
+
+    def trap_signal
+      Signal.trap(:INT) do
+        if RubyWolf::MAIN_PID == Process.pid
+          puts "Stopping server\n"
+        else
+          puts "Stopping worker #{Process.pid} \n"
+        end
+        exit
+      end
+
+      Signal.trap(:TERM) do
+        if RubyWolf::MAIN_PID == Process.pid
+          puts "Stopping server\n"
+          workers.each do |w|
+            Process.kill(:TERM, w.pid)
+          end
+        else
+          puts "Stopping worker #{Process.pid} \n"
+        end
+        sleep 1
+        exit
+      end
+    end
+  end
+end

data/lib/ruby_wolf/version.rb

@@ -0,0 +1,3 @@
+module RubyWolf
+  VERSION = "0.2.0"
+end

data/lib/ruby_wolf/worker.rb

@@ -0,0 +1,71 @@
+module RubyWolf
+  class Worker
+    attr_reader :pid, :server, :app, :socket, :connections
+
+    def initialize(server)
+      @server = server
+      @app = server.app
+      @socket = server.socket
+      @connections = []
+    end
+
+    def start
+      @pid = fork do
+        RubyWolf.log('Worker is ready')
+        handle_loop
+      end
+    end
+
+    private
+
+    def handle_loop
+      loop do
+        need_to_read = connections.select(&:need_to_read?)
+        need_to_write = connections.select(&:need_to_write?)
+
+        ready_to_read, ready_to_write, = IO.select(
+          need_to_read + [socket],
+          need_to_write
+        )
+
+        handle_read(ready_to_read)
+        handle_write(ready_to_write)
+      end
+    end
+
+    def handle_read(ready_to_read)
+      ready_to_read.each do |connection|
+        if connection == socket
+          accept_connection
+        else
+          connection.read
+          handle_request(connection) unless connection.need_to_read?
+        end
+      end
+    end
+
+    def handle_write(ready_to_write)
+      ready_to_write.each do |connection|
+        connection.write
+        close_connection(connection) unless connection.need_to_write?
+      end
+    end
+
+    def handle_request(connection)
+      handler = RubyWolf::Handler.new(app, connection) do |response|
+        connection.enqueue_write(response)
+      end
+      handler.process
+    end
+
+    def accept_connection
+      @connections << RubyWolf::Connection.new(socket.accept_nonblock)
+    rescue IO::WaitReadable, Errno::EINTR
+    end
+
+    def close_connection(connection)
+      connection.close
+      @connections.delete(connection)
+    end
+  end
+end

data/lib/ruby_wolf.rb

@@ -0,0 +1,28 @@
+require 'byebug'
+require 'rack'
+
+require 'ruby_wolf/version'
+require 'ruby_wolf/configuration'
+require 'ruby_wolf/connection'
+require 'ruby_wolf/handler'
+require 'ruby_wolf/server'
+require 'ruby_wolf/worker'
+require 'ruby_wolf/cli'
+
+module RubyWolf
+  MAIN_PID = Process.pid
+  CRLF = "\r\n".freeze
+  READ_SIZE = 16 * 1024
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  def self.log(content, mode = :info)
+    contents = content.to_s.split("\n")
+    object = Process.pid == MAIN_PID ? '[Main]' : "[Worker #{Process.pid}]"
+    contents.each do |line|
+      logger.send(mode, "#{object} #{line}")
+    end
+  end
+end

data/ruby_wolf.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_wolf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ruby_wolf'
+  spec.version       = RubyWolf::VERSION
+  spec.authors       = ['Nguyễn Quang Minh']
+  spec.email         = ['nguyenquangminh0711@gmail.com']
+
+  spec.summary       = 'A simple ruby web server using pre-fork and event loop'
+  spec.description   = 'My simple implementation of Rack web server using pre-fork and event loop'
+  spec.homepage      = 'https://github.com/nguyenquangminh0711/ruby_wolf'
+
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.bindir        = 'bin'
+  spec.executables   = ['ruby_wolf']
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rspec', '~>3.5.0', '>=3.5.0'
+  spec.add_development_dependency 'byebug', '~>9.0.0', '>=8.0.0'
+
+  spec.add_runtime_dependency 'rack', '~>2.0.0', '>=2.0.0'
+  spec.add_runtime_dependency 'http_parser.rb', '~>0.6.0', '>=0.6.0'
+end

data/spec/ruby_wolf/cli_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe RubyWolf::CLI do
+  let(:cli) { RubyWolf::CLI.new(args) }
+
+  before { cli.parse_options }
+
+  describe '#run' do
+    let(:args) { ['-d'] }
+    let(:app_double) { double }
+
+    context 'Rack file found' do
+      before do
+        allow(File).to receive(:exist?).and_return(true)
+        allow(::Rack::Builder).to receive(:parse_file).and_return(app_double)
+        allow_any_instance_of(RubyWolf::Server).to receive(:start)
+      end
+
+      it 'creates Rack app from the rack file' do
+        cli.run
+        expect(cli.app).to eql(app_double)
+      end
+
+      it 'starts ruby wolf server' do
+        expect_any_instance_of(RubyWolf::Server).to receive(:start)
+        cli.run
+        expect(cli.server).to be_a(RubyWolf::Server)
+        expect(cli.server.app).to eql(app_double)
+        expect(cli.server.configs).to eq(cli.configs)
+      end
+    end
+
+    context 'Rack file not found' do
+      before do
+        allow(File).to receive(:exist?).and_return(false)
+      end
+
+      it 'raises exception' do
+        expect do
+          cli.run
+        end.to raise_error(/rack file not found/i)
+      end
+    end
+  end
+
+  describe '#parse_options' do
+    describe 'daemon option' do
+      context 'default daemon' do
+        let(:args) { [] }
+        it { expect(cli.configs[:daemon]).to eql(false) }
+      end
+
+      context 'short form' do
+        let(:args) { ['-d'] }
+        it { expect(cli.configs[:daemon]).to eql(true) }
+      end
+
+      context 'full form' do
+        let(:args) { ['--daemon'] }
+        it { expect(cli.configs[:daemon]).to eql(true) }
+      end
+    end
+
+    describe 'host option' do
+      context 'default host' do
+        let(:args) { [] }
+        it { expect(cli.configs[:host]).to eql('0.0.0.0') }
+      end
+
+      context 'short form' do
+        let(:args) { ['-h localhost'] }
+        it { expect(cli.configs[:host]).to eql('localhost') }
+      end
+
+      context 'full form' do
+        let(:args) { ['--host=localhost'] }
+        it { expect(cli.configs[:host]).to eql('localhost') }
+      end
+    end
+
+    describe 'port option' do
+      context 'default port' do
+        let(:args) { [] }
+        it { expect(cli.configs[:port]).to eql(3000) }
+      end
+
+      context 'short form' do
+        let(:args) { ['-p 5000'] }
+        it { expect(cli.configs[:port]).to eql(5000) }
+      end
+
+      context 'full form' do
+        let(:args) { ['--port=5000'] }
+        it { expect(cli.configs[:port]).to eql(5000) }
+      end
+    end
+
+    describe 'worker option' do
+      context 'default worker' do
+        let(:args) { [] }
+        it { expect(cli.configs[:worker]).to eql(4) }
+      end
+
+      context 'short form' do
+        let(:args) { ['-w 20'] }
+        it { expect(cli.configs[:worker]).to eql(20) }
+      end
+
+      context 'full form' do
+        let(:args) { ['--worker=20'] }
+        it { expect(cli.configs[:port]).to eql(20) }
+      end
+    end
+  end
+end

data/spec/ruby_wolf/configuration_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe RubyWolf::Configuration do
+  let(:configs) { RubyWolf::Configuration.new }
+
+  describe '[]=' do
+    context 'key not exists' do
+      before do
+        configs[:hihi] = 'Test'
+      end
+
+      it 'store the value under the key' do
+        expect(configs[:hihi]).to eql('Test')
+      end
+    end
+
+    context 'key exists' do
+      before do
+        configs[:hihi] = 'Test'
+        configs[:hihi] = 'or not to test'
+      end
+
+      it 'updates the value under the key' do
+        expect(configs[:hihi]).to eql('or not to test')
+      end
+    end
+  end
+
+  describe '[]' do
+    context 'key exists' do
+      before do
+        configs[:hihi] = 'What'
+      end
+
+      it 'returns the value under the key' do
+        expect(configs[:hihi]).to eql('What')
+      end
+    end
+
+    context 'key not exists' do
+      it 'returns nil' do
+        expect(configs[:not_exist]).to eql(nil)
+      end
+    end
+  end
+end

data/spec/ruby_wolf_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe RubyWolf do
+  it "has a version number" do
+    expect(RubyWolf::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "ruby_wolf"

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: ruby_wolf
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Nguyễn Quang Minh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+description: My simple implementation of Rack web server using pre-fork and event
+  loop
+email:
+- nguyenquangminh0711@gmail.com
+executables:
+- ruby_wolf
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/ruby_wolf
+- lib/ruby_wolf.rb
+- lib/ruby_wolf/cli.rb
+- lib/ruby_wolf/configuration.rb
+- lib/ruby_wolf/connection.rb
+- lib/ruby_wolf/handler.rb
+- lib/ruby_wolf/server.rb
+- lib/ruby_wolf/version.rb
+- lib/ruby_wolf/worker.rb
+- ruby_wolf.gemspec
+- spec/ruby_wolf/cli_spec.rb
+- spec/ruby_wolf/configuration_spec.rb
+- spec/ruby_wolf_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/nguyenquangminh0711/ruby_wolf
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: A simple ruby web server using pre-fork and event loop
+test_files: []