griffin 0.1.0 → 0.1.1

data/examples/routeguide/routeguide_pb.rb

@@ -0,0 +1,37 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: routeguide.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "routeguide.Point" do
+    optional :latitude, :int32, 1
+    optional :longitude, :int32, 2
+  end
+  add_message "routeguide.Rectangle" do
+    optional :lo, :message, 1, "routeguide.Point"
+    optional :hi, :message, 2, "routeguide.Point"
+  end
+  add_message "routeguide.Feature" do
+    optional :name, :string, 1
+    optional :location, :message, 2, "routeguide.Point"
+  end
+  add_message "routeguide.RouteNote" do
+    optional :location, :message, 1, "routeguide.Point"
+    optional :message, :string, 2
+  end
+  add_message "routeguide.RouteSummary" do
+    optional :point_count, :int32, 1
+    optional :feature_count, :int32, 2
+    optional :distance, :int32, 3
+    optional :elapsed_time, :int32, 4
+  end
+end
+
+module Routeguide
+  Point = Google::Protobuf::DescriptorPool.generated_pool.lookup("routeguide.Point").msgclass
+  Rectangle = Google::Protobuf::DescriptorPool.generated_pool.lookup("routeguide.Rectangle").msgclass
+  Feature = Google::Protobuf::DescriptorPool.generated_pool.lookup("routeguide.Feature").msgclass
+  RouteNote = Google::Protobuf::DescriptorPool.generated_pool.lookup("routeguide.RouteNote").msgclass
+  RouteSummary = Google::Protobuf::DescriptorPool.generated_pool.lookup("routeguide.RouteSummary").msgclass
+end

data/examples/routeguide/routeguide_services_pb.rb

@@ -0,0 +1,61 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: routeguide.proto for package 'routeguide'
+# Original file comments:
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'grpc'
+require 'routeguide_pb'
+
+module Routeguide
+  module RouteGuide
+    # Interface exported by the server.
+    class Service
+
+      include GRPC::GenericService
+
+      self.marshal_class_method = :encode
+      self.unmarshal_class_method = :decode
+      self.service_name = 'routeguide.RouteGuide'
+
+      # A simple RPC.
+      #
+      # Obtains the feature at a given position.
+      #
+      # A feature with an empty name is returned if there's no feature at the given
+      # position.
+      rpc :GetFeature, Point, Feature
+      # A server-to-client streaming RPC.
+      #
+      # Obtains the Features available within the given Rectangle.  Results are
+      # streamed rather than returned at once (e.g. in a response message with a
+      # repeated field), as the rectangle may cover a large area and contain a
+      # huge number of features.
+      rpc :ListFeatures, Rectangle, stream(Feature)
+      # A client-to-server streaming RPC.
+      #
+      # Accepts a stream of Points on a route being traversed, returning a
+      # RouteSummary when traversal is completed.
+      rpc :RecordRoute, stream(Point), RouteSummary
+      # A Bidirectional streaming RPC.
+      #
+      # Accepts a stream of RouteNotes sent while a route is being traversed,
+      # while receiving other RouteNotes (e.g. from other users).
+      rpc :RouteChat, stream(RouteNote), stream(RouteNote)
+    end
+
+    Stub = Service.rpc_stub_class
+  end
+end

data/examples/routeguide_client.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/GlobalVars
+
+$LOAD_PATH.unshift File.expand_path('./examples/routeguide')
+
+require 'grpc_kit'
+require 'pry'
+require 'json'
+require 'logger'
+require 'routeguide_services_pb'
+
+RESOURCE_PATH = './examples/routeguide/routeguide.json'
+
+$logger = Logger.new(STDOUT)
+
+def get_feature(stub)
+  $logger.info('===== get_feature =====')
+  points = [
+    Routeguide::Point.new(latitude:  409_146_138, longitude: -746_188_906),
+    Routeguide::Point.new(latitude:  0, longitude: 0)
+  ]
+
+  points.each do |pt|
+    feature = stub.get_feature(pt, metadata: { 'metadata' => 'data1' })
+    if feature.name == ''
+      $logger.info("Found nothing at #{feature.inspect}")
+    else
+      $logger.info("Found '#{feature.name}' at #{feature.location.inspect}")
+    end
+  end
+end
+
+def list_features(stub)
+  $logger.info('===== list_features =====')
+  rect = Routeguide::Rectangle.new(
+    lo: Routeguide::Point.new(latitude: 400_000_000, longitude: -750_000_000),
+    hi: Routeguide::Point.new(latitude: 420_000_000, longitude: -730_000_000),
+  )
+
+  stream = stub.list_features(rect)
+
+  loop do
+    r = stream.recv
+    $logger.info("Found #{r.name} at #{r.location.inspect}")
+  end
+end
+
+def record_route(stub, size)
+  features = File.open(RESOURCE_PATH) do |f|
+    JSON.parse(f.read)
+  end
+
+  stream = stub.record_route({})
+
+  size.times do
+    location = features.sample['location']
+    point = Routeguide::Point.new(latitude: location['latitude'], longitude: location['longitude'])
+    puts "Next point is #{point.inspect}"
+    stream.send_msg(point)
+    sleep(rand(0..1))
+  end
+
+  resp = stream.close_and_recv
+  puts "summary: #{resp[0].inspect}"
+end
+
+opts = {}
+
+if ENV['GRPC_INTERCEPTOR']
+  require_relative 'interceptors/client_logging_interceptor'
+  opts[:interceptors] = [LoggingInterceptor.new]
+elsif ENV['GRPC_TIMEOUT']
+  opts[:timeout] = Integer(ENV['GRPC_TIMEOUT'])
+end
+
+stub = Routeguide::RouteGuide::Stub.new('localhost', 50051, **opts)
+
+get_feature(stub)
+list_features(stub)
+record_route(stub, 10)
+
+# rubocop:enable Style/GlobalVars

data/examples/routeguide_server.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('./examples/routeguide')
+
+require 'grpc_kit'
+require 'pry'
+require 'json'
+require 'routeguide_services_pb'
+require 'logger'
+
+class Server < Routeguide::RouteGuide::Service
+  RESOURCE_PATH = './examples/routeguide/routeguide.json'
+
+  def initialize
+    @logger = Logger.new(STDOUT)
+    File.open(RESOURCE_PATH) do |f|
+      features = JSON.parse(f.read)
+      @features = Hash[features.map { |x| [x['location'], x['name']] }]
+    end
+  end
+
+  def get_feature(point, ctx)
+    name = @features.fetch({ 'longitude' => point.longitude, 'latitude' => point.latitude }, '')
+    @logger.info("Point longitude=#{point.longitude}, latitude=#{point.latitude}, metadata=#{ctx.metadata}")
+    Routeguide::Feature.new(location: point, name: name)
+  end
+
+  def list_features(rect, stream)
+    @logger.info('===== list_features =====')
+
+    @features.each do |location, name|
+      if name.nil? || name == '' || !in_range(location, rect)
+        next
+      end
+
+      pt = Routeguide::Point.new(location)
+      resp = Routeguide::Feature.new(location: pt, name: name)
+      @logger.info(resp)
+      stream.send_msg(resp)
+    end
+  end
+
+  def record_route(stream)
+    @logger.info('===== record_route =====')
+    distance = 0
+    count = 0
+    features = 0
+    start_at = Time.now.to_i
+    last = nil
+
+    loop do
+      point = stream.recv # XXX: raise StopIteration
+      @logger.info(point)
+
+      count += 1
+      name = @features.fetch({ 'longitude' => point.longitude, 'latitude' => point.latitude }, '')
+      unless name == ''
+        features += 1
+      end
+
+      last = point
+      distance += calculate_distance(point, last)
+    end
+
+    Routeguide::RouteSummary.new(
+      point_count: count,
+      feature_count: features,
+      distance: distance,
+      elapsed_time: Time.now.to_i - start_at,
+    )
+  end
+
+  private
+
+  COORD_FACTOR = 1e7
+  RADIUS = 637_100
+
+  def calculate_distance(point_a, point_b)
+    lat_a = (point_a.latitude / COORD_FACTOR) * Math::PI / 180
+    lat_b = (point_b.latitude / COORD_FACTOR) * Math::PI / 180
+    lon_a = (point_a.longitude / COORD_FACTOR) * Math::PI / 180
+    lon_b = (point_b.longitude / COORD_FACTOR) * Math::PI / 180
+
+    delta_lat = lat_a - lat_b
+    delta_lon = lon_a - lon_b
+    a = Math.sin(delta_lat / 2)**2 + Math.cos(lat_a) * Math.cos(lat_b) + Math.sin(delta_lon / 2)**2
+    (2 * RADIUS * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))).to_i
+  end
+
+  def in_range(point, rect)
+    longitudes = [rect.lo.longitude, rect.hi.longitude]
+    left = longitudes.min
+    right = longitudes.max
+
+    latitudes = [rect.lo.latitude, rect.hi.latitude]
+    bottom = latitudes.min
+    top = latitudes.max
+    (point['longitude'] >= left) && (point['longitude'] <= right) && (point['latitude'] >= bottom) && (point['latitude'] <= top)
+  end
+end
+
+sock = TCPServer.new(50051)
+
+opts = {}
+
+if ENV['GRPC_INTERCEPTOR']
+  require_relative 'interceptors/server_logging_interceptor'
+  opts[:interceptors] = [LoggingInterceptor.new]
+end
+
+server = GrpcKit::Server.new(**opts)
+server.handle(Server.new)
+server.run
+
+loop do
+  conn = sock.accept
+  server.session_start(conn)
+end

data/griffin.gemspec

@@ -1,27 +1,33 @@
+# frozen_string_literal: true
 
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "griffin/version"
+require 'griffin/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "griffin"
+  spec.name          = 'griffin'
   spec.version       = Griffin::VERSION
   spec.authors       = ['ganmacs']
   spec.email         = ['ganmacs@gmail.com']
 
-  spec.summary       = ""
-  spec.description   = ""
-  spec.homepage      = "https://github.com/ganmacs/griffin"
-  spec.license       = "MIT"
+  spec.summary       = 'Send and Receive RPCs from Ruby'
+  spec.description   = 'Send and Receive RPCs from Ruby'
+  spec.homepage      = 'https://github.com/ganmacs/griffin'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+
+  spec.add_dependency 'connection_pool', '~> 2.2.2'
+  spec.add_dependency 'grpc_kit', '~> 0.1.5'
+  spec.add_dependency 'serverengine', '~> 2.0.7'
 end

data/lib/griffin/connection_pool/multi_timed_stack.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'connection_pool'
+
+module Griffin
+  module ConnectionPool
+    # This code is based on https://github.com/drbrain/net-http-persistent/blob/0e5a8fb8a27deff37247ddb3bc5e6c9e390face5/lib/net/http/persistent/timed_stack_multi.rb
+    class MultiTimedStack < ::ConnectionPool::TimedStack
+      def initialize(size = 0, &block)
+        super
+
+        @enqueued = 0
+        @ques = Hash.new { |h, k| h[k] = [] }
+        @lru = []
+      end
+
+      def empty?
+        length <= 0
+      end
+
+      def length
+        @max - @created + @enqueued
+      end
+
+      private
+
+      def connection_stored?(options = {})
+        !@ques[options[:connection_args]].empty?
+      end
+
+      def fetch_connection(options = {})
+        connection_args = options[:connection_args]
+
+        @enqueued -= 1
+        lru_update(connection_args)
+        @ques[connection_args].pop
+      end
+
+      def shutdown_connections
+        @ques.each_key do |key|
+          super(connection_args: key)
+        end
+      end
+
+      def store_connection(obj, options = {})
+        @ques[options[:connection_args]].push(obj)
+        @enqueued += 1
+      end
+
+      def try_create(options = {})
+        connection_args = options[:connection_args]
+
+        if @created >= @max && @enqueued >= 1
+          oldest = lru_delete
+          @ques[oldest].pop
+
+          @created -= 1
+        end
+
+        if @created < @max
+          obj = @create_block.call(connection_args)
+          @created += 1
+          lru_update(connection_args)
+          obj
+        end
+      end
+
+      def lru_update(key)
+        @lru.delete(key)
+        @lru.push(key)
+      end
+
+      def lru_delete
+        @lru.shift
+      end
+    end
+  end
+end

data/lib/griffin/connection_pool/pool.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'connection_pool'
+
+require 'griffin/connection_pool/multi_timed_stack'
+
+module Griffin
+  module ConnectionPool
+    class Pool
+      DEFAULTS = { size: 5, timeout: 5 }.freeze
+
+      def initialize(options = {}, &block)
+        raise ArgumentError, 'Connection pool requires a block' unless block
+
+        options = DEFAULTS.merge(options)
+
+        @size = Integer(options.fetch(:size))
+        @timeout = Integer(options.fetch(:timeout))
+
+        @available = Griffin::ConnectionPool::MultiTimedStack.new(@size, &block)
+        @key = :"current-#{@available.object_id}"
+        Thread.current[@key] = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def checkin(key)
+        stack = Thread.current[@key][key]
+        raise 'no connections are checked out' if stack.empty?
+
+        conn = stack.pop
+        if stack.empty?
+          @available.push(conn, connection_args: key)
+        end
+        nil
+      end
+
+      def checkout(key)
+        stack = Thread.current[@key][key]
+
+        conn =
+          if stack.empty?
+            @available.pop(connection_args: key)
+          else
+            stack.last
+          end
+
+        stack.push(conn)
+
+        conn
+      end
+
+      def shutdown(&block)
+        @available.shutdown(&block)
+      end
+    end
+  end
+end

data/lib/griffin/counting_semaphore.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Griffin
+  class CountingSemaphore
+    def initialize(size)
+      @size = size
+      @queue = Queue.new
+      @size.times { @queue.push(0) }
+    end
+
+    def wait
+      @queue.pop
+    end
+
+    def signal
+      @queue.push(0)
+    end
+  end
+end

data/lib/griffin/engine/server.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'griffin/listener'
+
+module Griffin
+  module Engine
+    module Server
+      attr_reader :core, :listener
+
+      def initialize
+        @core = Griffin::Server.new
+      end
+
+      def before_run
+        config[:services].each do |s|
+          @core.handle(s)
+        end
+      end
+
+      def stop(stop_graceful)
+        super # needed
+      end
+
+      # def after_start; end
+      # def restart; end
+      # def reload_config; end
+    end
+  end
+end

data/lib/griffin/engine/single.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'griffin/server'
+require 'griffin/listener'
+
+module Griffin
+  module Engine
+    class Single
+      def self.create(config)
+        new(Griffin::Server.new, config)
+      end
+
+      def initialize(server, config)
+        @server = server
+        @config = config
+        @listener = Griffin::Listener.new(@config[:bind], @config[:port])
+      end
+
+      def run
+        @config[:services].each do |s|
+          @server.handle(s)
+        end
+
+        install_handler
+
+        @server.before_run
+        @server.run(@listener.listen)
+      end
+
+      def install_handler
+        trap('INT') do
+          @server.shutdown
+        end
+
+        trap('TERM') do
+          @server.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/griffin/engine/worker.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'griffin/listener'
+
+module Griffin
+  module Engine
+    module Worker
+      def before_fork
+        @listener = Griffin::Listener.new(config[:bind], config[:port])
+        server.core.before_run(worker_id)
+      end
+
+      def run
+        server.core.run(@listener.listen)
+      ensure
+        @listener.close
+      end
+
+      def stop
+        server.core.shutdown
+      end
+
+      # def after_fork; end
+      # def reload; end
+    end
+  end
+end

data/lib/griffin/engine.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'serverengine'
+require 'griffin/engine/single'
+require 'griffin/engine/server'
+require 'griffin/engine/worker'
+
+module Griffin
+  module Engine
+    def self.start(config, cluster: false)
+      if cluster
+        Griffin.logger.info("Griffin v#{Griffin::VERSION} starts as cluster mode")
+        ServerEngine.create(Griffin::Engine::Server, Griffin::Engine::Worker, config).run
+      else
+        Griffin.logger.info("Griffin v#{Griffin::VERSION} starts as single mode")
+        Griffin::Engine::Single.create(config).run
+      end
+    end
+  end
+end

data/lib/griffin/listener.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module Griffin
+  class Listener
+    DEFAULT_BACKLOG_SIZE = 1024
+
+    # @params host [String]
+    # @params port [Integer]
+    # @params backlog [Integer]
+    def initialize(host, port, backlog: DEFAULT_BACKLOG_SIZE)
+      @host = host
+      @port = port
+      @backlog = backlog
+    end
+
+    def listen(tcp_opt: true)
+      @sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      if tcp_opt
+        @sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      end
+
+      @sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true)
+
+      @sock.bind(Addrinfo.tcp(@host, @port))
+      @sock.listen(@backlog)
+      Griffin.logger.info("Start listening #{@host}:#{@port}")
+      @sock
+    end
+
+    def close
+      @sock.close
+    end
+  end
+end