canson 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19cfa746b443d79afafcaf8feeb8336e8f42ef80
+  data.tar.gz: 2169d634254c158235eea0fc4c49078fccb5934f
+SHA512:
+  metadata.gz: 6423e71a01382ca72b94a1d5c90006add6197ca3b5b083dda1f187ae37e652d1312acb5e4a45c2bf52c948405834926fbdb3d7fd751bc7436a316855c6b893a7
+  data.tar.gz: cc584f2eab5c44b0a47773129821c9e82191007552a3038e5d7caa449a1e5673f159030d3669d7705394799e8e4de64871b6eba3d9bc45166e1f06c81a7d8702

data/.rubocop.yml

@@ -0,0 +1,35 @@
+# inherit_from: .rubocop_todo.yml
+
+AllCops:
+  Exclude:
+    - 'bin/*'
+    - 'config/**/*'
+    - 'deps/**/*'
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/erlport/**/*'
+    - 'Guardfile'
+    - 'Rakefile'
+    - 'Gemfile'
+    - 'canson.gemspec'
+    - '*.ex'
+    - '*.exs'
+
+Metrics/CyclomaticComplexity:
+  Max: 9
+
+Metrics/PerceivedComplexity:
+  Max: 9
+
+Metrics/ClassLength:
+  Max: 250
+
+# If you are using the --enable-frozen-string-literal flag
+# You might also want to add this:
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Style/SafeNavigation:
+  # Safe navigation may cause a statement to start returning `nil` in addition
+  # to whatever it used to return.
+  ConvertCodeThatCanStartToReturnNil: true

data/.travis.yml

@@ -0,0 +1,15 @@
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.1
+bundler_args: --jobs=2
+cache: bundler
+before_install: gem install bundler -v 1.13.6
+
+script:
+  - bundle install
+  - rake
+  - gem install bundler-audit
+  - bundle-audit update
+  - bundle-audit check

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+gemspec
+group :development, :test do
+  gem 'bundler', '~> 1.7'
+  gem 'rake', '~> 11.3.0'
+  gem 'byebug'
+  gem 'minitest', '~> 5.0'
+  gem 'guard', '~> 2.14.0'
+  gem 'guard-bundler', '~> 2.1.0'
+  gem 'guard-minitest', '~> 2.4.6'
+  gem 'rubocop', '~> 0.45.0'
+  gem 'guard-rubocop', '~> 1.2.0'
+  gem 'minitest-reporters', '~> 1.1.11'
+  gem 'minitest-vcr', '~> 1.4.0'
+  gem 'webmock', '~> 2.1.0'
+  gem "rack-test", "~> 0.6"
+end

data/Guardfile

@@ -0,0 +1,24 @@
+# require 'rubocop'
+# require 'dotenv'
+# Dotenv.load(File.expand_path('../.env.test', __FILE__))
+
+guard :bundler do
+  require 'guard/bundler'
+  require 'guard/bundler/verify'
+  helper = Guard::Bundler::Verify.new
+  files = ['Gemfile']
+  files += Dir['*.gemspec'] if files.any? { |f| helper.uses_gemspec?(f) }
+  # Assume files are symlinked from somewhere
+  files.each { |file| watch(helper.real_path(file)) }
+end
+
+guard :minitest, test_folders: 'spec', test_file_patterns: '*_spec.rb', all_on_start: false do
+  watch(%r{^spec/(.*)_spec\.rb$})
+  watch(%r{^lib/canson/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+end
+
+guard :rubocop, all_on_start: false do
+  watch(%r{.+\.rb$})
+  watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jaigouk Kim
+
+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,132 @@
+# Canson
+
+small rack based framework that can run websocket. 20K connections can be handled
+
+## Run the example chat app
+
+```
+cd spec/test_app_root
+bundle install
+bundler exec iodine -p 3000 -t 16 -w 4
+```
+
+open localhost:3000 in browser
+
+## Example app
+
+in `spec/test_app_root`
+
+```
+require 'canson'
+class TestApp < Canson::Base
+
+  def self.print_out
+    puts 'hijack'
+  end
+
+  get '/' do
+    print_out
+    {results: 'hi'}
+  end
+
+  get '/ask' do |params|
+    name = params[:name]
+    {results: name}
+  end
+
+   on_open do
+    puts '================================'
+    puts 'We have a websocket connection'
+    puts '================================'
+  end
+
+  on_close do
+    puts "Bye Bye... #{count} connections left..."
+  end
+
+  on_shutdown do
+    write 'The server is shutting down, goodbye.'
+  end
+
+  on_message do |params|
+    data = params[:data]
+    ws = params[:ws]
+    nickname = params[:nickname]
+    tmp = "#{nickname}: #{data}"
+    ws.write tmp
+    ws.each { |h| h.write tmp }
+    puts '================================'
+    puts "got message: #{data} encoded as #{data.encoding}"
+    puts "broadcasting #{tmp.bytesize} bytes with encoding #{tmp.encoding}"
+    puts '================================'
+  end
+end
+```
+
+```
+require './test_app.rb'
+run TestApp.new
+```
+
+
+## Usage
+
+Given the following piece of ruby code:
+
+```ruby
+# config.ru
+
+require "canson"
+
+get "/index" do
+  { results: [1, 2, 3] }
+end
+```
+
+> The server is run via `bundle exec rackup --port 3000`.
+
+When requested with `curl http://localhost:3000/bla -i`, it should return:
+
+```
+HTTP/1.1 200 OK
+Content-Type: application/json
+
+{"results": [1, 2, 3]}
+```
+
+Given the following piece of ruby code:
+
+```ruby
+# config.ru
+
+require "trialday"
+
+get "/bla" do
+  { results: [1, 2, 3] }
+end
+
+post "/bla" do |params|
+  name = params[:name]
+
+  { name: name }
+end
+```
+
+When requested with `curl http://localhost:3000/index -i`, it should return:
+
+```
+HTTP/1.1 200 OK
+Content-Type: application/json
+
+{"results": [1, 2, 3]}
+```
+
+When requested with `curl -XPOST http://localhost:3000/bla -i -H "Content-Type: application/json" -d '{"name": "Mario"}'`, it should return:
+
+```
+HTTP/1.1 200 OK
+Content-Type: application/json
+
+{"name": "Mario"}
+```
+

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'dotenv'
+require 'dotenv/tasks'
+Dotenv.load(File.expand_path('../.env.test', __FILE__))
+
+Rake::TestTask.new(test: :dotenv) do |t|
+  t.libs << 'spec'
+  t.libs << 'lib'
+  t.test_files = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "canson"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/iodine

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'iodine'
+require 'rack'
+
+if ARGV[0] =~ /(\-\?)|(help)|(\?)$/
+  puts <<-EOS
+Iodine's HTTP/Websocket server version #{Iodine::VERSION}
+Use:
+    iodine <options> <filename>
+Both <options> and <filename> are optional.
+Available options:
+ -p          Port number. Default: 3000.
+ -t          Number of threads. Default: 1 => single worker thread.
+ -w          Number of worker processes. Default: 1 => a single process.
+ -www        Public folder for static file serving. Default: nil (none).
+ -v          Log responses.
+ -q          Never log responses.
+ -warmup     Warmup invokes autoloading (lazy loading) during server startup.
+ -maxbd      Maximum Mb per HTTP message (max body size). Default: ~50Mb.
+ -maxms      Maximum Bytes per Websocket message. Default: ~250Kb.
+ -ping       Websocket ping interval in seconds. Default: 40 seconds.
+ <filename>  Defaults to: config.ru
+Example:
+    iodine -p 80
+    iodine -p 8080 path/to/app/conf.ru
+    iodine -p 8080 -w 4 -t 16
+EOS
+  exit(0)
+end
+
+filename = (ARGV[-2].to_s[0] != '-' && ARGV[-1].to_s[0] != '-' && ARGV[-1]) || 'config.ru'
+app, opt = Rack::Builder.parse_file filename
+if ARGV.index('-maxbd') && ARGV[ARGV.index('-maxbd') + 1]
+  Iodine::Rack.max_body_size = ARGV[ARGV.index('-maxbd') + 1].to_i
+end
+if ARGV.index('-maxms') && ARGV[ARGV.index('-maxms') + 1]
+  Iodine::Rack.max_msg_size = ARGV[ARGV.index('-maxms') + 1].to_i
+end
+if ARGV.index('-ping') && ARGV[ARGV.index('-ping') + 1]
+  Iodine::Rack.ws_timeout = ARGV[ARGV.index('-ping') + 1].to_i
+end
+if ARGV.index('-www') && ARGV[ARGV.index('-www') + 1]
+  Iodine::Rack.public = ARGV[ARGV.index('-www') + 1]
+end
+Iodine::Rack.log = true if ARGV.index('-v')
+Iodine::Rack.log = false if ARGV.index('-q')
+Iodine.warmup if ARGV.index('-warmup')
+Iodine::Rack.run(app, opt)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/canson.gemspec

@@ -0,0 +1,45 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'canson/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "canson"
+  spec.version       = Canson::VERSION
+  spec.authors       = ["Jaigouk Kim"]
+  spec.email         = ["ping@jaigouk.kim"]
+
+  spec.summary       = %q{grpc}
+  spec.description   = %q{grpc based webframework}
+  spec.homepage      = "https://github.com/jaigouk/canson"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'dry-monads', '~> 0.2.1'
+  spec.add_dependency 'dry-matcher', '~> 0.5'
+  spec.add_dependency 'dry-transaction', '~> 0.8'
+  spec.add_dependency 'grpc', '~> 1.0.1'
+  spec.add_dependency 'http-2', '~> 0.8.2'
+  spec.add_dependency 'http_parser.rb', '~> 0.6'
+  spec.add_dependency 'dotenv'
+  spec.add_runtime_dependency 'iodine', '~> 0.2.3'
+  spec.add_runtime_dependency 'rack', '~> 2.0.1'
+  spec.add_runtime_dependency 'tilt', '~> 2.0.5'
+  spec.add_runtime_dependency 'mustermann', '~> 0.4'
+  spec.add_runtime_dependency 'mime-types', '~> 2.4'
+end

data/lib/canson.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'tilt'
+require 'rack'
+require 'mustermann'
+require 'mime-types'
+require 'canson/version'
+require 'canson/web_socket'
+require 'canson/route_map'
+require 'canson/responder'
+require 'canson/base'
+
+module Canson
+  class RequestError
+  end
+end

data/lib/canson/base.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'rack/utils'
+require 'rack/media_type'
+require 'json'
+
+module Canson
+  # used to create a new app
+  # App < CansonBase
+  #   get '/foo' do
+  #     {result: 'ok'}
+  #   end
+  # end
+  class Base
+    extend Forwardable
+    include Mustermann
+
+    attr_reader :klass
+    attr_accessor :responder
+
+    def_delegators :@klass, :routes, :method_missing, :filename
+
+    class << self
+      # def inherited(subclass)
+      #   # subclass.routes @routes
+      #   subclass.filename @filename
+      # end
+
+      [:on_open, :on_close, :on_shutdown, :on_message].each do |m|
+        define_method m do |&block|
+          @responder = Responder.new :ws, &block
+          routes[m]['websocket_method'] = @responder
+          @responder.call
+        end
+      end
+
+      [:get, :post, :put, :delete, :options].each do |m|
+        define_method m do |path, opts = {}, &block|
+          path = ::Mustermann.new path, opts
+          @responder = Responder.new m, &block
+          routes[m][path.to_s] = @responder
+          @responder.call
+        end
+      end
+
+      def routes(r = nil)
+        return @routes = r if r
+        @routes ||= Hash.new { |h, k| h[k] = RouteMap.new }
+      end
+    end
+
+    def initialize(responder = Responder.new)
+      @responder = responder
+      @klass = self.class
+      @websocket = nil
+      @filename = File.expand_path('./index.html')
+    end
+
+    def filename
+      @filename
+    end
+
+    def call(env)
+      m = env['REQUEST_METHOD'].tr('/', '').downcase.to_sym
+      target = routes[m][env['PATH_INFO']]
+
+      if m == :get && env['PATH_INFO'] == '/' && File.file?(filename)
+        out = File.open(filename)
+        return [200, { 'X-Sendfile' => filename,
+          'Content-Length' => out.size }, out]
+      end
+
+      return handle_socket(env) if env['HTTP_UPGRADE'] == 'websocket'
+      return  [404, {}, ['no route']] unless target
+      return call_result(env, target)
+    rescue => e
+      puts e.message
+      [500, {}, ["server error #{e.message}".to_json]]
+    end
+
+    def handle_socket(env)
+      nickname = env['PATH_INFO'][1..-1].force_encoding 'UTF-8'
+      if env['HTTP_UPGRADE'.freeze] =~ /websocket/i
+        routes[:on_message][nickname] ||= Canson::Websocket.new(env)
+        routes[:on_message][nickname].on_open = routes[:on_open]['websocket_method']
+        routes[:on_message][nickname].on_close = routes[:on_close]['websocket_method']
+        routes[:on_message][nickname].on_shutdown = routes[:on_shutdown]['websocket_method']
+        routes[:on_message][nickname].on_message = routes[:on_message]['websocket_method']
+        env['upgrade.websocket'.freeze] = routes[:on_message][nickname]
+        return [0, {}, []]
+      end
+    end
+
+    private
+
+    def call_result(env, target)
+      param = get_param(env)
+      result = if param.nil?
+                 self.class.instance_exec(&(target.call))
+               else
+                 self.class.instance_exec(param, &(target.call))
+               end
+      return [404, {}, ['not found']] if result.values.include? nil
+      [200, { 'Content-Type' => 'application/json' }, [result.to_json]]
+    end
+
+    def get_param(env)
+      req = Rack::Request.new(env)
+      param = req.params.empty? ? req.body.read : req.params
+      return if param.empty?
+      param_to_hash(param)
+    end
+
+    def param_to_hash(param)
+      if param.class == Hash
+        if param.keys.first.include?(':')
+          return to_hash(JSON.parse(param.keys.first))
+        end
+        to_hash(param)
+      else
+        to_hash(JSON.parse(param))
+      end
+    end
+
+    def to_hash(ele)
+      ele.map { |k, v| [k.to_sym, v] }.to_h
+    end
+  end
+end

data/lib/canson/responder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Canson
+  # responsible to return the block
+  class Responder
+    attr_reader :method, :response_handler
+    attr_writer :base
+
+    def initialize(method = nil, &block)
+      @method = method
+      @response_handler = block
+    end
+
+    def call
+      @response_handler
+    end
+  end
+end

data/lib/canson/route_map.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Canson
+  # keeps routes and responders
+  class RouteMap
+    def initialize
+      @hash = {}
+    end
+
+    def []=(route, responder)
+      @hash[route] = responder
+    end
+
+    def [](route)
+      _path, responder = @hash.find { |k, _v| k.match(route) }
+      responder
+    end
+  end
+end

data/lib/canson/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Canson
+  VERSION = '0.1.0'.freeze
+end

data/lib/canson/web_socket.rb

@@ -0,0 +1,44 @@
+module Canson
+  class Websocket
+    def initialize(env)
+      @nickname = env['PATH_INFO'][1..-1].force_encoding 'UTF-8'
+      @on_open = nil
+      @on_close = nil
+      @on_shutdown = nil
+      @on_message = nil
+    end
+
+    def on_open=(responder)
+      @on_open = responder
+    end
+
+    def on_close=(responder)
+      @on_close = responder
+    end
+
+    def on_shutdown=(responder)
+      @on_shutdown = responder
+    end
+
+    def on_message=(responder)
+      @on_message = responder
+    end
+
+    def on_open
+      @on_open.class.instance_exec({count: self.count}, &(@on_open.call))
+    end
+
+    def on_close
+      @on_close.class.instance_exec({count: self.count}, &(@on_close.call))
+    end
+
+    def on_shutdown
+      @on_shutdown.class.instance_exec(&(@on_shutdown.call))
+    end
+
+    def on_message(data)
+      @on_message.class.instance_exec({data: data, ws: self, nickname: @nickname},
+        &(@on_message.call))
+    end
+  end
+end

data/refs.md

@@ -0,0 +1,113 @@
+
+## Parsing
+
+https://github.com/sinatra/mustermann
+https://github.com/tmm1/http_parser.rb
+https://github.com/ngauthier/tubesock
+
+## Streaming
+
+https://rosenfeld.herokuapp.com/en/articles/ruby-rails/2016-07-02-the-sad-state-of-streaming-in-ruby-web-applications
+Each request thread (or process) has access to a "response" object that accepts a "write" call that goes directly to the socket's output (or after a "flush" call).
+It would be awesome if Ruby web applications had the option to use a more flexible API, more friendly to streamed responses, including SSE and websockets. Hijacking currently seems to be considered a second-class citizen since they are usually ignored by major web frameworks like Rails itself.
+
+https://bowild.wordpress.com/2016/07/31/the-dark-side-of-the-rack/
+what if everything we had to do to upgrade from HTTP to Websockets was something like this env[upgrade.websockets] = MyCallbacks.new(env)…?
+
+We can unify the IO polling for all IO objects (HTTP, Websocket, no need for hijack). This is bigger then you think.
+We can parse websocket data before entering the GIL, winning some of our concurrency back. This also means we can better utilize multi-core CPUs.
+
+We don’t need to know anything about network programming – let the people programming servers do what they do best and let the people who write web applications focus on their application logic.
+https://gist.github.com/boazsegev/1466442c913a8dd4271178cab9d98a27
+https://github.com/boazsegev/iodine
+
+http://rubykaigi.org/2015/presentations/tenderlove
+
+https://github.com/SamSaffron/message_bus
+
+rack hijack
+https://github.com/ngauthier/tubesock
+
+https://bowild.wordpress.com/2016/07/31/the-dark-side-of-the-rack/
+
+https://blog.heroku.com/real_time_rails_implementing_websockets_in_rails_5_with_action_cable
+
+
+https://blog.heroku.com/real_time_rails_implementing_websockets_in_rails_5_with_action_cable
+
+
+https://klibert.pl/statics/python-and-elixir/#/
+
+https://www.reddit.com/r/ruby/comments/4r9alo/the_sad_state_of_streaming_support_in_ruby_web/
+
+If your servers were implementing HTTP/2, then hijacking the IO would break the protocol and (hopefully) terminate the connection with no data being received.
+HTTP/2 is a binary protocol with packet headers and footer. If the hijacked IO doesn't write the data as HTTP/2 packets and sends the end of stream flag upon completion, then the receiving party will simply assume the data is garbage and (if implementing the standard correctly) will disconnect.
+This is the reason I though hijacking is limited and approaching an end-of-life cycle for HTTP requests (will soon be impossible). It's only possible long term implementation is HTTP upgrade requests which usually means a long-lived connection is being established with either Websockets or HTTP/2 (although other protocols can also be used with the technique).
+
+https://gist.github.com/TiagoCardoso1983/591d48cfde04219f801fa7fd7966571c
+
+For http2, the same above stands, with a few add-ons:
+Ruby's openssl is (at least, it was) missing some bugfixes for ALPN negotiation (is it still valid?).
+
+Ruby is currently missing an optimized parser for http2 requests (not a big hinderance, as there's an http2 pure ruby gem around).
+http2-to-http1 on the web server is seemingly "good enough".
+http2 protocol is only a big gain if one is using an evented application server, as the big thing over there is the frame multiplexing.
+
+So, we have thin and reel. Both of them use C-written event loops (reel uses libev), which means we're out of ruby core, and are not widely used (correct me if I'm wrong, but is reel compatible with most available middlewares? Is it running rails for anyone?).
+
+rack needs to die and be born again. event-based middlewares, #call(request, response) instead of #call(env), a proper stream object with less socket-y semantics, the rack hijack hack won't stand.
+
+nio4r (celluloid-io/reel) looks much better, but ships with a patched version of libev because no-ruby-core-GIL-API). It brings with it the libev's "problems", which are no Windows support or no support for not-network file descriptors (file, pipes) (not really a problem when there is no competition though).
+
+### grpc
+
+* stackoverflow
+
+http://stackoverflow.com/questions/35065875/how-to-bring-a-grpc-defined-api-to-the-web-browser
+
+We want to build a Javascript/HTML gui for our gRPC-microservices. Since gRPC is not supported on the browser side, we thought of using web-sockets to connect to a node.js server, which calls the target service via grpc. We struggle to find an elegant solution to do this. Especially, since we use gRPC streams to push events between our micro-services. It seems that we need a second RPC system, just to communicate between the front end and the node.js server. This seems to be a lot of overhead and additional code that must be maintained.
+
+Does anyone have experience doing something like this or has an idea how this could be solved?
+
+https://github.com/tmc/grpc-websocket-proxy sounds like it may meet your needs. This translates json over web sockets to grpc (layer on top of grpc-gateway).
+
+
+https://coreos.com/blog/gRPC-protobufs-swagger.html
+
+One of the key reasons we chose gRPC is because it uses HTTP/2, enabling applications to present both a HTTP 1.1 REST+JSON API and an efficient gRPC interface on a single TCP port. This gives developers compatibility with the REST web ecosystem while advancing a new, high-efficiency RPC protocol. With Go 1.6 recently released, Go ships with a stable net/http2 package by default.
+
+
+https://github.com/grpc-ecosystem/grpc-gateway
+
+https://github.com/ruby-concurrency/concurrent-ruby/blob/master/doc/channel.md
+
+https://github.com/paralin/grpc-bus
+
+# RubyConf 2016
+
+RubyConf 2016 - To Clojure and back: writing and rewriting in Ruby by Phill MV
+ https://www.youtube.com/watch?v=doZ0XAc9Wtc
+ 
+ 1. "value" objects
+ tcrayford/values
+
+ 2. "manager" object
+ controller: handles input
+ model: value object. handles persistence(db query, save)
+ manager: handles state
+```
+ class PackageManager
+   attr_reader :platform, :release
+   def initialize platform, release
+     @platform = platform
+     @release = release
+   end
+   # methods never modify inputs.
+   # never set internal state
+   def find_existing_packages package_list
+     return Package.none if package_list.empty?
+     query = Package.where platform: self.platform,
+                           release: self.release
+     query.search_qunique_fields(package_list.map(&:uniq_values))
+   end
+```

metadata

@@ -0,0 +1,235 @@
+--- !ruby/object:Gem::Specification
+name: canson
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jaigouk Kim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-monads
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: dry-matcher
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: dry-transaction
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: http-2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  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: iodine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description: grpc based webframework
+email:
+- ping@jaigouk.kim
+executables:
+- console
+- iodine
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".env"
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/iodine
+- bin/setup
+- canson.gemspec
+- lib/canson.rb
+- lib/canson/base.rb
+- lib/canson/responder.rb
+- lib/canson/route_map.rb
+- lib/canson/version.rb
+- lib/canson/web_socket.rb
+- refs.md
+homepage: https://github.com/jaigouk/canson
+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.7
+signing_key: 
+specification_version: 4
+summary: grpc
+test_files: []