toycol 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e39fd4d4d223eef7eb8e86059fd061ebbb24259a1259b7f5b8bef228d6d9836
-  data.tar.gz: 8d90ae7ed408d76a46da7726a280560d245e1372bca9d2a0857efe7bc22d6a3d
+  metadata.gz: 9eb79d412c62ad9b86922964fa583b4fa1ed64b941c74654874b93d385d5665e
+  data.tar.gz: 8d915a6bfc7677096164b7fa773e32fad7669ff0b847eb2306be885899298362
 SHA512:
-  metadata.gz: 10d74fd171b7eec5618b1aeca4035a3f9bff05c12864285fb43fa83d1d53a97523276a19ac3a6185929e82854ce3701dd0f7d5963a55c38536cbe71828327809
-  data.tar.gz: a73c3c5c7992ba1bebb34f8db9bfc8061a066a6c2b30ead33c8dfdc79a8b540092f540b793dd67c164dc277766dd7e6ce030b00b17d30148c28f5993fab4157e
+  metadata.gz: c988be01719a879b367ea0da7323bc00100d4373f3516ab504e03fb92d26b3c2f0e3fe9e4411f84d139b97100d2e3342cebb4eb2e344674dadcd62ecadbf06bb
+  data.tar.gz: fc5ab9812a9f87006052c22614b6cdae7257db0919c3f95f0f30bba5e238b0787ba2c83ba08eb363089d06df41edd68ff5d048e31fb4116fc1a91bfe7823c872

data/.github/workflows/main.yml

@@ -5,12 +5,15 @@ on: [push,pull_request]
 jobs:
   build:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [2.6, 2.7, 3.0, head]
     steps:
     - uses: actions/checkout@v2
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.0.0
+        ruby-version: ${{ matrix.ruby }}
         bundler-cache: true
     - name: Run the default task
       run: bundle exec rake

data/.gitignore

@@ -7,4 +7,5 @@
 /spec/reports/
 /tmp/
 
+.ruby-version
 Gemfile.lock

data/.rubocop.yml

@@ -9,7 +9,10 @@ AllCops:
     - 'Rakefile'
     - 'toycol.gemspec'
   NewCops: enable
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 2.6
+
+Style/Documentation:
+  Enabled: false
 
 Style/StringLiterals:
   Enabled: true
@@ -21,3 +24,16 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+
+Metrics:
+  Exclude:
+    - lib/toycol/proxy.rb
+
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/ClassLength:
+  Max: 400
+
+Metrics/MethodLength:
+  Max: 15

data/CHANGELOG.md

@@ -1,5 +1,5 @@
 ## [Unreleased]
 
-## [0.1.0] - 2021-07-12
+## [0.0.1] - 2021-07-12
 
 - Initial release

data/README.md

@@ -1,8 +1,6 @@
 # Toycol
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/toycol`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Toy Application Protocol framework
 
 ## Installation
 
@@ -22,7 +20,7 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+WIP
 
 ## Development
 

data/bin/toycol

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/toycol"
+
+Toycol::Command.run(ARGV)

data/examples/duck/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "toycol", path: "../../"

data/examples/duck/Protocolfile.duck

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+Toycol::Protocol.define(:duck) do
+  custom_status_codes(
+    600 => "I'm afraid you are not a duck..."
+  )
+  additional_request_methods "OTHER"
+
+  request.path do |message|
+    %r{(?<path>/\w*)}.match(message)[:path]
+  end
+
+  request.query do |message|
+    /\?(?<query>.+)/.match(message) { |m| m[:query] }
+  end
+
+  request.http_method do |message|
+    case message.scan(/quack/).size
+    when 2 then "GET"
+    else "OTHER"
+    end
+  end
+end

data/examples/duck/config_duck.ru

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "rack"
+require "toycol"
+
+Toycol::Protocol.use(:duck)
+
+# Duck protocol application
+class App
+  def call(env)
+    case env["REQUEST_METHOD"]
+    when "GET"
+      case env["PATH_INFO"]
+      when "/posts"
+        return app_for_get_with_query if env["QUERY_STRING"] == "user_id=1"
+
+        app_for_get
+      when "/" then app_for_get_to_root
+      end
+    when "OTHER" then app_for_other
+    end
+  end
+
+  private
+
+  def app_for_get_with_query
+    [
+      200,
+      { "Content-Type" => "text/html" },
+      ["quack quack, I am the No.1 duck\n"]
+    ]
+  end
+
+  def app_for_get
+    [
+      200,
+      { "Content-Type" => "text/html" },
+      ["quack quack, quack quack, quack, quack\n", "quack quack, I am the No.1 duck\n"]
+    ]
+  end
+
+  def app_for_get_to_root
+    [
+      200,
+      { "Content-Type" => "text/html" },
+      ["Hello, This app is running on Sample duck protocol.\n"]
+    ]
+  end
+
+  def app_for_other
+    [
+      600,
+      { "Content-Type" => "text/html" },
+      ["Sorry, this application is only for ducks...\n"]
+    ]
+  end
+end
+
+run App.new

data/examples/rubylike/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "toycol", path: "../../"

data/examples/rubylike/Protocolfile.rubylike

@@ -0,0 +1,18 @@
+Toycol::Protocol.define(:rubylike) do
+  custom_status_codes(
+    700 => "Hmm...",
+  )
+
+  additional_request_methods "OTHER"
+
+  request.path do |message|
+    /['"](?<path>.+)['"]/.match(message)[:path]
+  end
+
+  request.http_method do |message|
+    case /\.(?<method>[A-z]+)/.match(message)&.captures&.first
+    when "get" then "GET"
+    else "OTHER"
+    end
+  end
+end

data/examples/rubylike/config_rubylike.ru

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rack"
+require "toycol"
+
+Toycol::Protocol.use(:rubylike)
+
+class App
+  def call(env)
+    case env["REQUEST_METHOD"]
+    when "GET"
+      [
+        200,
+        { "Content-Type" => "text/html" },
+        ["I love ruby!\n", "I love RubyKaigi!\n"]
+      ]
+    when "OTHER"
+      [
+        700,
+        { "Content-Type" => "text/html" },
+        ["Sorry, but I'd like you to speak more like a Ruby programmer...\n"]
+      ]
+    end
+  end
+end
+
+run App.new

data/examples/safe_ruby/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "toycol", path: "../../"

data/examples/safe_ruby/Protocolfile.safe_ruby

@@ -0,0 +1,47 @@
+module SafeRuby
+  PARSER_REGEX = /["'](?<path>\/.*)["']\.(?<method>[A-z]+)/
+  QUERY_REGEX  = /query?.*\{(?<query>.*)\}/
+  INPUT_REGEX  = /input?.*\{(?<input>.*)\}/
+end
+
+Toycol::Protocol.define(:safe_ruby) do |message|
+  using Module.new {
+    refine String do
+      # Ex. '/posts'.get
+      # Ex. (with query string) '/posts'.get(query: { user_id: 2 })
+      def get(options = {})
+        Toycol::Protocol.request.query { options[:query] } if options[:query]
+        Toycol::Protocol.request.http_method { "GET" }
+      end
+
+      # Ex. '/posts'.post(input: { user_id: 1, body: 'This is a post request' })
+      def post(options = {})
+        Toycol::Protocol.request.input { options[:input] } if options[:input]
+        Toycol::Protocol.request.http_method { "POST" }
+      end
+
+      def parse_as_queries
+        split(",").map { |str| str.scan(/\w+/).join("=") }
+      end
+
+      def parse_as_inputs
+        split(",").map { |str| str.split(":").map { |s| s.strip! && s.gsub(/['"]/, "") }.join("=") }
+      end
+    end
+  }
+
+  path, method = SafeRuby::PARSER_REGEX.match(message) { |m| [m[:path], m[:method]] }
+  query = SafeRuby::QUERY_REGEX.match(message) { |m| m[:query].parse_as_queries }&.join("&")
+  input = SafeRuby::INPUT_REGEX.match(message) { |m| m[:input].parse_as_inputs }&.join("&")
+  args  = {}
+
+  request.path { path }
+
+  %i[query input].each do |k|
+    if v = binding.local_variable_get(k)
+      args[*k] = v
+    end
+  end
+
+  request_path.public_send(method, args)
+end

data/examples/safe_ruby/config_safe_ruby.ru

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "rack"
+require "toycol"
+
+Toycol::Protocol.use(:safe_ruby)
+
+class App
+  def call(env)
+    case env["REQUEST_METHOD"]
+    when "GET"
+      case env["PATH_INFO"]
+      when "/posts"
+        return app_for_get_with_query if env["QUERY_STRING"] == "user_id=2"
+
+        app_for_get
+      end
+    when "POST"
+      input   = env["rack.input"].gets
+      created = input.split("&").map { |str| str.split("=") }.to_h
+
+      app_for_post(user_id: created["user_id"], body: created["body"])
+    end
+  end
+
+  private
+
+  def app_for_get_with_query
+    [
+      200,
+      { "Content-Type" => "text/html" },
+      ["User<2> I love RubyKaigi!\n"]
+    ]
+  end
+
+  def app_for_get
+    [
+      200,
+      { "Content-Type" => "text/html" },
+      ["User<1> I love Ruby!\n", "User<2> I love RubyKaigi!\n"]
+    ]
+  end
+
+  def app_for_post(user_id:, body:)
+    [
+      201,
+      { "Content-Type" => "text/html", "Location" => "/posts" },
+      ["User<1> I love Ruby!\n",
+       "User<2> I love RubyKaigi!\n",
+       "User<#{user_id}> #{body}\n"]
+    ]
+  end
+end
+
+run App.new

data/examples/safe_ruby_with_sinatra/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gem "sinatra"
+gem "sinatra-contrib"
+gem "toycol", path: "../../"

data/examples/safe_ruby_with_sinatra/Protocolfile.safe_ruby_with_sinatra

@@ -0,0 +1,44 @@
+module SafeRubyWithSinatra
+  PARSER_REGEX = /["'](?<path>\/.*)["']\.(?<method>[A-z]+)/
+  QUERY_REGEX  = /query?.*\{(?<query>.*)\}/
+  INPUT_REGEX  = /input?.*\{(?<input>.*)\}/
+end
+
+Toycol::Protocol.define(:safe_ruby_with_sinatra) do |message|
+  using Module.new {
+    refine String do
+      def get(options = {})
+        Toycol::Protocol.request.query { options[:query] } if options[:query]
+        Toycol::Protocol.request.http_method { "GET" }
+      end
+
+      def post(options = {})
+        Toycol::Protocol.request.input { options[:input] } if options[:input]
+        Toycol::Protocol.request.http_method { "POST" }
+      end
+
+      def parse_as_queries
+        split(",").map { |str| str.scan(/\w+/).join("=") }
+      end
+
+      def parse_as_inputs
+        split(",").map { |str| str.split(":").map { |s| s.strip! && s.gsub(/['"]/, "") }.join("=") }
+      end
+    end
+  }
+
+  path, method = SafeRubyWithSinatra::PARSER_REGEX.match(message) { |m| [m[:path], m[:method]] }
+  query = SafeRubyWithSinatra::QUERY_REGEX.match(message) { |m| m[:query].parse_as_queries }&.join("&")
+  input = SafeRubyWithSinatra::INPUT_REGEX.match(message) { |m| m[:input].parse_as_inputs }&.join("&")
+  args  = {}
+
+  request.path { path }
+
+  %i[query input].each do |k|
+    if v = binding.local_variable_get(k)
+      args[*k] = v
+    end
+  end
+
+  request_path.public_send(method, args)
+end

data/examples/safe_ruby_with_sinatra/app.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "sinatra/base"
+require "sinatra/reloader"
+require "toycol"
+require_relative "post"
+
+Toycol::Protocol.use(:safe_ruby_with_sinatra)
+
+class App < Sinatra::Base
+  set :server, :toycol
+  set :port, 9292
+
+  get "/posts" do
+    @posts = params[:user_id] ? Post.where(user_id: params[:user_id]) : Post.all
+
+    erb :index
+  end
+
+  post "/posts" do
+    Post.new(user_id: params[:user_id], body: params[:body])
+    @posts = Post.all
+
+    erb :index
+  end
+
+  run! if app_file == $PROGRAM_NAME
+end

data/examples/safe_ruby_with_sinatra/post.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Post
+  @posts ||= []
+
+  class << self
+    def all
+      @posts
+    end
+
+    def where(user_id: nil)
+      @posts.select do |post|
+        post.user_id == Integer(user_id) if user_id
+      end
+    end
+
+    def insert(record)
+      @posts << record
+    end
+  end
+
+  attr_reader :user_id, :body
+
+  def initialize(user_id:, body:)
+    @user_id = Integer(user_id)
+    @body    = body
+
+    self.class.insert self
+  end
+end
+
+# Initial records
+Post.new(user_id: 1, body: "I love Ruby!")
+Post.new(user_id: 2, body: "I love RubyKaigi!")

data/examples/safe_ruby_with_sinatra/views/index.erb

@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta charset="UTF-8">
+  </head>
+
+  <body>
+    <h1>This app is running on Safe Ruby protocol</h1>
+
+    <div>
+      <ul>
+        <% @posts.each do |post| %>
+          <li><%= "User<#{post.user_id}> #{post.body}" %></li>
+        <% end %>
+      </ul>
+    </div>
+
+    <div>
+      <form action='/posts' method='post'>
+        <div>
+          <label>User ID</label>
+          <input type="number" name="user_id">
+        </div>
+        <div>
+          <label>Content</label>
+          <input type="text" name="body">
+        </div>
+        <div>
+          <input type="submit" value="Post">
+        </div>
+      </form>
+  </body>
+</html>

data/examples/unsafe_ruby/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "toycol", path: "../../"

data/examples/unsafe_ruby/Protocolfile.unsafe_ruby

@@ -0,0 +1,15 @@
+Toycol::Protocol.define(:ruby) do |message|
+  using Module.new {
+    refine String do
+      def get
+        Toycol::Protocol.request.path do |message|
+          /['"](?<path>.+)['"]/.match(message)[:path]
+        end
+
+        Toycol::Protocol.request.http_method { |_| "GET" }
+      end
+    end
+  }
+
+  instance_eval message
+end

data/examples/unsafe_ruby/config_unsafe_ruby.ru

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rack"
+require "toycol"
+
+Toycol::Protocol.use(:ruby)
+
+class App
+  def call(env)
+    case env["REQUEST_METHOD"]
+    when "GET"
+      case env["PATH_INFO"]
+      when "/posts"
+        [
+          200,
+          { "Content-Type" => "text/html" },
+          ["I love Ruby!\n", "I've successfully accessed using instance_eval!\n"]
+        ]
+      end
+    end
+  end
+end
+
+run App.new

data/lib/rack/handler/toycol.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rack/handler"
+require "rack/handler/puma"
+
+module Rack
+  module Handler
+    class Toycol
+      def self.run(app, options = {})
+        if (child_pid = fork)
+          environment  = ENV["RACK_ENV"] || "development"
+          default_host = environment == "development" ? "localhost" : "0.0.0.0"
+
+          host = options.delete(:Host) || default_host
+          port = options.delete(:Port) || "9292"
+
+          ::Toycol::Proxy.new(host, port).start
+          Process.waitpid(child_pid)
+        else
+          puts "Toycol starts Puma in single mode, listening on unix://#{::Toycol::UNIX_SOCKET_PATH}"
+          Rack::Handler::Puma.run(app, **{ Host: ::Toycol::UNIX_SOCKET_PATH, Silent: true })
+        end
+      end
+    end
+
+    register :toycol, Toycol
+  end
+end

data/lib/toycol.rb

@@ -1,8 +1,26 @@
 # frozen_string_literal: true
 
+require "fileutils"
+
+require_relative "toycol/const"
+require_relative "toycol/helper"
+require_relative "toycol/protocol"
+require_relative "toycol/proxy"
+require_relative "rack/handler/toycol"
+
+Dir["#{FileUtils.pwd}/Protocolfile*"].sort.each { |f| load f }
+
+require_relative "toycol/command"
 require_relative "toycol/version"
 
 module Toycol
   class Error < StandardError; end
-  # Your code goes here...
+
+  class UnauthorizedMethodError < Error; end
+
+  class UnauthorizedRequestError < Error; end
+
+  class UndefinedRequestMethodError < Error; end
+
+  class UnknownStatusCodeError < Error; end
 end

data/lib/toycol/client.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Toycol
+  class Client
+    @port = 9292
+    CHUNK_SIZE = 1024 * 16
+
+    class << self
+      attr_writer :port
+
+      def execute!(request_message, &block)
+        socket = TCPSocket.new("localhost", @port)
+        socket.write(request_message)
+        puts "[Toycol] Sent request message: #{request_message}\n---"
+
+        response_message = []
+        response_message << socket.readpartial(CHUNK_SIZE) until socket.eof?
+        response_message = response_message.join
+
+        block ||= default_proc
+        block.call(response_message)
+      ensure
+        socket.close
+      end
+
+      private
+
+      def default_proc
+        proc do |message|
+          puts "[Toycol] Received response message:\n\n"
+          puts message
+        end
+      end
+    end
+  end
+end

data/lib/toycol/command.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "./client"
+
+module Toycol
+  class Command
+    class Options
+      class << self
+        def parse!(argv)
+          options            = {}
+          option_parser      = create_option_parser
+          sub_command_parser = create_sub_command_parser
+
+          begin
+            option_parser.order!(argv)
+            options[:command]         = argv.shift
+            options[:request_message] = argv.shift if %w[client c].include? options[:command]
+
+            sub_command_parser[options[:command]].parse!(argv)
+          rescue OptionParser::MissingArgument, OptionParser::InvalidOption, ArgumentError => e
+            abort e.message
+          end
+
+          options
+        end
+
+        def create_option_parser
+          OptionParser.new do |opt|
+            opt.banner = "Usage: #{opt.program_name} [-h|--help] [-v|--version] <command> <args>"
+            display_adding_summary(opt)
+
+            opt.on_head("-h", "--help", "Show this message") do
+              puts opt.help
+              exit
+            end
+
+            opt.on_head("-v", "--version", "Show Toycol version") do
+              opt.version = Toycol::VERSION
+              puts opt.ver
+              exit
+            end
+          end
+        end
+
+        def create_sub_command_parser
+          sub_command_parser = Hash.new { |_k, v| raise ArgumentError, "'#{v}' is not sub command" }
+          sub_command_parser["client"] = client_option_parser
+          sub_command_parser["c"]      = client_option_parser
+          sub_command_parser
+        end
+
+        private
+
+        def client_option_parser
+          OptionParser.new do |opt|
+            opt.on("-p=PORT_NUMBER", "--port=PORT_NUMBER", "Set port number") do |n|
+              ::Toycol::Client.port = n
+            end
+          end
+        end
+
+        def display_adding_summary(opt)
+          opt.separator ""
+          opt.separator "Client command options:"
+          client_command_help_messages.each do |command|
+            opt.separator [opt.summary_indent, command[:name].ljust(31), command[:summary]].join(" ")
+          end
+        end
+
+        def client_command_help_messages
+          [
+            { name: "client -p=PORT_NUMBER", summary: "Send request to server" }
+          ]
+        end
+      end
+    end
+
+    def self.run(argv)
+      new(argv).execute
+    end
+
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def execute
+      options = Options.parse!(@argv)
+      command = options.delete(:command)
+
+      case command
+      when "client", "c" then ::Toycol::Client.execute!(options[:request_message])
+      end
+    end
+  end
+end

data/lib/toycol/const.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Toycol
+  DEFAULT_HTTP_REQUEST_METHODS = %w[
+    GET
+    HEAD
+    POST
+    OPTIONS
+    PUT
+    DELETE
+    TRACE
+    PATCH
+    LINK
+    UNLINK
+  ].freeze
+
+  DEFAULT_HTTP_STATUS_CODES = {
+    100 => "Continue",
+    101 => "Switching Protocols",
+    102 => "Processing",
+    200 => "OK",
+    201 => "Created",
+    202 => "Accepted",
+    203 => "Non-Authoritative Information",
+    204 => "No Content",
+    205 => "Reset Content",
+    206 => "Partial Content",
+    207 => "Multi-Status",
+    208 => "Already Reported",
+    226 => "IM Used",
+    300 => "Multiple Choices",
+    301 => "Moved Permanently",
+    302 => "Found",
+    303 => "See Other",
+    304 => "Not Modified",
+    305 => "Use Proxy",
+    307 => "Temporary Redirect",
+    308 => "Permanent Redirect",
+    400 => "Bad Request",
+    401 => "Unauthorized",
+    402 => "Payment Required",
+    403 => "Forbidden",
+    404 => "Not Found",
+    405 => "Method Not Allowed",
+    406 => "Not Acceptable",
+    407 => "Proxy Authentication Required",
+    408 => "Request Timeout",
+    409 => "Conflict",
+    410 => "Gone",
+    411 => "Length Required",
+    412 => "Precondition Failed",
+    413 => "Payload Too Large",
+    414 => "URI Too Long",
+    415 => "Unsupported Media Type",
+    416 => "Range Not Satisfiable",
+    417 => "Expectation Failed",
+    418 => "I'm A Teapot",
+    421 => "Misdirected Request",
+    422 => "Unprocessable Entity",
+    423 => "Locked",
+    424 => "Failed Dependency",
+    426 => "Upgrade Required",
+    428 => "Precondition Required",
+    429 => "Too Many Requests",
+    431 => "Request Header Fields Too Large",
+    451 => "Unavailable For Legal Reasons",
+    500 => "Internal Server Error",
+    501 => "Not Implemented",
+    502 => "Bad Gateway",
+    503 => "Service Unavailable",
+    504 => "Gateway Timeout",
+    505 => "HTTP Version Not Supported",
+    506 => "Variant Also Negotiates",
+    507 => "Insufficient Storage",
+    508 => "Loop Detected",
+    510 => "Not Extended",
+    511 => "Network Authentication Required"
+  }.freeze
+
+  UNIX_SOCKET_PATH = ENV["TOYCOL_SOCKET_PATH"] || "/tmp/toycol.socket"
+end

data/lib/toycol/helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Toycol
+  module Helper
+    private
+
+    def safe_execution!(&block)
+      safe_executionable_tp.enable(&block)
+    end
+
+    def safe_executionable_tp
+      @safe_executionable_tp ||= TracePoint.new(:script_compiled) do |tp|
+        if tp.binding.receiver == Toycol::Protocol && tp.method_id.to_s.match?(unauthorized_methods_regex)
+          raise Toycol::UnauthorizedMethodError, <<~ERROR
+            - Unauthorized method was called!
+            You can't use methods that may cause injections in your protocol.
+            Ex. Kernel.#eval, Kernel.#exec, Kernel.#require and so on.
+          ERROR
+        end
+      end
+    end
+
+    def unauthorized_methods_regex
+      /(.*eval|.*exec|`.+|%x\(|system|open|require|load)/
+    end
+  end
+end

data/lib/toycol/protocol.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Toycol
+  # This class is for protocol definition and parsing request messages
+  class Protocol
+    @definements          = {}
+    @protocol_name        = nil
+    @http_status_codes    = Toycol::DEFAULT_HTTP_STATUS_CODES.dup
+    @http_request_methods = Toycol::DEFAULT_HTTP_REQUEST_METHODS.dup
+    @custom_status_codes  = nil
+    @additional_request_methods = nil
+
+    class << self
+      # For protocol definition
+      def define(protocol_name = nil, &block)
+        @definements[protocol_name] = block
+      end
+
+      # For application which use the protocol
+      def use(protocol_name)
+        @protocol_name = protocol_name
+      end
+
+      # For server which use the protocol
+      def run!(message)
+        @request_message = message.chomp
+
+        return unless (block = @definements[@protocol_name])
+
+        instance_exec(@request_message, &block)
+      end
+
+      # For protocol definition: Define custom status codes
+      if RUBY_VERSION >= "2.7"
+        def custom_status_codes(**custom_status_codes)
+          @custom_status_codes = custom_status_codes
+        end
+      else
+        def custom_status_codes(custom_status_codes)
+          @custom_status_codes = custom_status_codes
+        end
+      end
+
+      # For protocol definition: Define adding request methods
+      def additional_request_methods(*additional_request_methods)
+        @additional_request_methods = additional_request_methods
+      end
+
+      # For protocol definition: Define how to parse the request message
+      def request
+        @request ||= Class.new do
+          def self.path(&block)
+            @path = block
+          end
+
+          def self.query(&block)
+            @query = block
+          end
+
+          def self.http_method(&block)
+            @http_method = block
+          end
+
+          def self.input(&block)
+            @input = block
+          end
+        end
+      end
+
+      # For server: Get the request path
+      def request_path
+        request_path = request.instance_variable_get("@path").call(request_message)
+
+        raise UnauthorizedRequestError, "This request path is too long" if request_path.size >= 2048
+
+        if request_path.scan(%r{[/\w\d\-_]}).size < request_path.size
+          raise UnauthorizedRequestError,
+                "This request path contains unauthorized character"
+        end
+
+        request_path
+      end
+
+      # For server: Get the request method
+      def request_method
+        @http_request_methods.concat @additional_request_methods if @additional_request_methods
+        request_method = request.instance_variable_get("@http_method").call(request_message)
+
+        unless @http_request_methods.include? request_method
+          raise UndefinedRequestMethodError, "This request method is undefined"
+        end
+
+        request_method
+      end
+
+      # For server: Get the query string
+      def query
+        return unless (parse_query_block = request.instance_variable_get("@query"))
+
+        parse_query_block.call(request_message)
+      end
+
+      # For server: Get the input body
+      def input
+        return unless (parsed_input_block = request.instance_variable_get("@input"))
+
+        parsed_input_block.call(request_message)
+      end
+
+      # For server: Get the message of status code
+      def status_message(status)
+        @http_status_codes.merge!(@custom_status_codes) if @custom_status_codes
+
+        unless (message = @http_status_codes[status])
+          raise UnknownStatusCodeError, "Application returns unknown status code"
+        end
+
+        message
+      end
+
+      private
+
+      attr_reader :request_message
+    end
+  end
+end

data/lib/toycol/proxy.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Toycol
+  class Proxy
+    include Helper
+
+    def initialize(host, port)
+      @host           = host
+      @port           = port
+      @request_method = nil
+      @path           = nil
+      @query          = nil
+      @input          = nil
+      @protocol       = ::Toycol::Protocol
+      @proxy          = TCPServer.new(@host, @port)
+    end
+
+    CHUNK_SIZE = 1024 * 16
+
+    def start
+      puts <<~MESSAGE
+        Toycol is running on #{@host}:#{@port}
+        => Use Ctrl-C to stop
+      MESSAGE
+
+      loop do
+        trap(:INT) { shutdown }
+
+        @client = @proxy.accept
+
+        while !@client.closed? && !@client.eof?
+          begin
+            request = @client.readpartial(CHUNK_SIZE)
+            puts "[Toycol] Received message: #{request.inspect.chomp}"
+
+            safe_execution! { @protocol.run!(request) }
+            assign_parsed_attributes!
+
+            http_request_message = build_http_request_message
+            puts "[Toycol] Message has been translated to HTTP request message: #{http_request_message.inspect}"
+            transfer_to_server(http_request_message)
+          rescue StandardError => e
+            puts "#{e.class} #{e.message} - closing socket."
+            e.backtrace.each { |l| puts "\t#{l}" }
+            @proxy.close
+            @client.close
+          end
+        end
+        @client.close
+      end
+    end
+
+    private
+
+    def assign_parsed_attributes!
+      @request_method = @protocol.request_method
+      @path  = @protocol.request_path
+      @query = @protocol.query
+      @input = @protocol.input
+    end
+
+    def build_http_request_message
+      request_message = "#{request_line}#{request_header}\r\n"
+      request_message += @input if @input
+      request_message
+    end
+
+    def request_line
+      "#{@request_method} #{request_path} HTTP/1.1\r\n"
+    end
+
+    def request_path
+      return @path unless @request_method == "GET"
+
+      "#{@path}#{"?#{@query}" if @query && !@query.empty?}"
+    end
+
+    def request_header
+      "Content-Length: #{@input&.bytesize || 0}\r\n"
+    end
+
+    def transfer_to_server(request_message)
+      UNIXSocket.open(Toycol::UNIX_SOCKET_PATH) do |server|
+        server.write request_message
+        server.close_write
+        puts "[Toycol] Successed to Send HTTP request message to server"
+
+        response_message = []
+        response_message << server.readpartial(CHUNK_SIZE) until server.eof?
+        response_message = response_message.join
+        puts "[Toycol] Received response message from server: #{response_message.lines.first}"
+
+        _, status_code, status_message = response_message.lines.first.split
+
+        if (custom_message = @protocol.status_message(status_code.to_i)) != status_message
+          response_message = response_message.sub(status_message, custom_message)
+          puts "[Toycol] Status message has been translated to custom status message: #{custom_message}"
+        end
+
+        @client.write response_message
+        @client.close_write
+        puts "[Toycol] Finished to response to client"
+        server.close
+      end
+    end
+
+    def shutdown
+      puts "[Toycol] Catched SIGINT -> Stop to server"
+      exit
+    end
+  end
+end

data/lib/toycol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Toycol
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/toycol.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = "Toy Application Protocol framework"
   spec.homepage      = "https://github.com/shioimm/toycol"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/shioimm/toycol"
@@ -27,9 +27,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, checkout our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_dependency "puma"
+  spec.add_dependency "rack", "~> 2.0"
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: toycol
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Misaki Shioi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-12 00:00:00.000000000 Z
-dependencies: []
+date: 2021-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: Toy Application Protocol framework
 email:
 - shioi.mm@gmail.com
@@ -28,7 +56,32 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- bin/toycol
+- examples/duck/Gemfile
+- examples/duck/Protocolfile.duck
+- examples/duck/config_duck.ru
+- examples/rubylike/Gemfile
+- examples/rubylike/Protocolfile.rubylike
+- examples/rubylike/config_rubylike.ru
+- examples/safe_ruby/Gemfile
+- examples/safe_ruby/Protocolfile.safe_ruby
+- examples/safe_ruby/config_safe_ruby.ru
+- examples/safe_ruby_with_sinatra/Gemfile
+- examples/safe_ruby_with_sinatra/Protocolfile.safe_ruby_with_sinatra
+- examples/safe_ruby_with_sinatra/app.rb
+- examples/safe_ruby_with_sinatra/post.rb
+- examples/safe_ruby_with_sinatra/views/index.erb
+- examples/unsafe_ruby/Gemfile
+- examples/unsafe_ruby/Protocolfile.unsafe_ruby
+- examples/unsafe_ruby/config_unsafe_ruby.ru
+- lib/rack/handler/toycol.rb
 - lib/toycol.rb
+- lib/toycol/client.rb
+- lib/toycol/command.rb
+- lib/toycol/const.rb
+- lib/toycol/helper.rb
+- lib/toycol/protocol.rb
+- lib/toycol/proxy.rb
 - lib/toycol/version.rb
 - toycol.gemspec
 homepage: https://github.com/shioimm/toycol
@@ -46,7 +99,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="