grpc_kit 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f95aa58f7261b6edcb3c31051fbaa164af1ac447f6a12af7d6d962752e0631f9
-  data.tar.gz: c3520fab3bd5daaff92954af7d665c504dc65dce4131f5d083a35e6cfb45ec4b
+  metadata.gz: 278f9b00d1dd37370eae8a829ec68742bcfdd9f693e9189d3abfd0404d2cb31a
+  data.tar.gz: 334798bf715bbb1aacab0507457c90a9289c0249c728728e53c7663359318f58
 SHA512:
-  metadata.gz: 678ecbed6f6a0e2dc74b2d3d176c2ae83688162d197132f361c7f233bae8dddd3d12c06dee7d87ca0b1d0f0df7f8de07d97b78ac9cf539e270a1de4b86e9e0ae
-  data.tar.gz: f387757d9332d280ae52ff1d4ca7417731b84a4078d0b9074747bbda42e1ee0b2e5a020c993fcdddcbae4cca76dd5c1ce51c5d44914975dd177b9e7a4cd927ef
+  metadata.gz: 25a7c01b82e0726470147c38be66243226483ddf1dafd6b292201cf4c3da99949dc99a2a298e9166f395b531cf936d279a52789730601e32a416378551f2992a
+  data.tar.gz: 70fa89ff80eebc5d23bcb0e9b1bec9b3190bba7b2fcb00e7d3eb55f0b1c6ac17a3e9beb4738f69558d740995d45eaccfdd557a44fa02d3ebfdbbf4845d8e9f9c

data/.rubocop.yml

@@ -35,7 +35,7 @@ Style/TrailingCommaInArguments:
 Style/SafeNavigation:
   Enabled: false
 
-Style/PredicateName:
+Naming/PredicateName:
   NamePrefixBlacklist:
     - "is_"
     - "have_"
@@ -49,13 +49,23 @@ Style/SignalException:
 Style/SingleLineBlockParams:
   Enabled: false
 
-Lint/UnderscorePrefixedVariableName:
+Style/NumericLiterals:
+  Enabled: false
+
+Style/GuardClause:
   Enabled: false
 
-##################### Metrics ##################################
+Style/NumericPredicate:
+  Enabled: false
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
+Lint/UnderscorePrefixedVariableName:
+  Enabled: false
 
 Metrics/AbcSize:
-  Max: 30
+  Max: 50
 
 Metrics/CyclomaticComplexity:
   Max: 10
@@ -64,7 +74,13 @@ Metrics/LineLength:
   Max: 160
 
 Metrics/MethodLength:
-  Max: 20
+  Max: 40
 
 Metrics/PerceivedComplexity:
-  Max: 8
+  Max: 20
+
+Metrics/ClassLength:
+  Max: 200
+
+Metrics/BlockLength:
+  Max: 40

data/examples/interceptors/client_logging_interceptor.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'grpc_kit'
+
+class LoggingInterceptor < GRPC::ClientInterceptor
+  def request_response(request: nil, method: nil, **)
+    now = Time.now.to_i
+    GrpcKit.logger.info("Started request #{request}, method=#{method.name}, service_name=#{method.receiver.class.service_name}")
+    yield.tap do
+      GrpcKit.logger.info("Elapsed Time: #{Time.now.to_i - now}")
+    end
+  end
+
+  def client_streamer(call: nil, method: nil, **)
+    GrpcKit.logger.info("Started request method=#{method.name}, service_name=#{method.receiver.class.service_name}")
+    yield(LoggingStream.new(call))
+  end
+
+  def server_streamer(call: nil, method: nil, **)
+    GrpcKit.logger.info("Started request method=#{method.name}, service_name=#{method.receiver.class.service_name}")
+    yield(LoggingStream.new(call))
+  end
+
+  def bidi_streamer(**)
+    yield
+  end
+
+  class LoggingStream
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def send_msg(msg, **opts)
+      GrpcKit.logger.info("logging interceptor send #{msg}")
+      @stream.send_msg(msg, opts)
+    end
+
+    def recv(**opt)
+      @stream.recv(opt).tap do |v|
+        GrpcKit.logger.info("logging interceptor recv #{v}")
+      end
+    end
+
+    def close_and_recv
+      @stream.close_and_recv
+    end
+  end
+end

data/examples/interceptors/server_logging_interceptor.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'grpc_kit'
+
+class LoggingInterceptor < GRPC::ServerInterceptor
+  def request_response(request: nil, call: nil, method: nil)
+    now = Time.now.to_i
+    GrpcKit.logger.info("Started request #{request}, method=#{method.name}, service_name=#{method.receiver.class.service_name}")
+    yield(request, call).tap do
+      GrpcKit.logger.info("Elapsed Time: #{Time.now.to_i - now}")
+    end
+  end
+
+  def client_streamer(call: nil, method: nil)
+    GrpcKit.logger.info("Started request method=#{method.name}, service_name=#{method.receiver.class.service_name}")
+    yield(LoggingStream.new(call))
+  end
+
+  def server_streamer(call: nil, method: nil, **)
+    GrpcKit.logger.info("Started request method=#{method.name}, service_name=#{method.receiver.class.service_name}")
+    yield(LoggingStream.new(call))
+  end
+
+  def bidi_streamer(**)
+    yield
+  end
+
+  class LoggingStream
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def send_msg(msg, **opt)
+      GrpcKit.logger.info("logging interceptor send #{msg}")
+      @stream.send_msg(msg, opt)
+    end
+
+    def recv(**opt)
+      @stream.recv(**opt).tap do |v|
+        GrpcKit.logger.info("logging interceptor recv #{v}")
+      end
+    end
+  end
+end

data/examples/routeguide_client.rb

@@ -1,23 +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'
 
-stub = Routeguide::RouteGuide::Stub.new('localhost', 50051)
+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)
-    puts "get_feature #{feature.name}, #{feature.location}"
+    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

@@ -6,26 +6,109 @@ 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.load(f.read)
+      features = JSON.parse(f.read)
       @features = Hash[features.map { |x| [x['location'], x['name']] }]
     end
   end
 
-  def get_feature(point, _call)
+  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)
 
-server = GrpcKit::Server.new
+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
 

data/grpc_kit.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'ds9', '~> 1.1.1'
+  spec.add_dependency 'ds9', '~> 1.2.0'
   spec.add_dependency 'google-protobuf', '~> 3.6.1'
   spec.add_dependency 'googleapis-common-protos-types', '~> 1.0.2'
 

data/lib/grpc.rb

@@ -3,5 +3,6 @@
 # Compat file for xx_services_pb.rb
 require 'grpc_kit'
 require 'grpc_kit/grpc/generic_service'
+require 'grpc_kit/grpc/interceptor'
 
 GRPC = GrpcKit::GRPC

data/lib/grpc_kit/client.rb

@@ -2,106 +2,58 @@
 
 require 'socket'
 require 'grpc_kit/session/client'
+require 'grpc_kit/session/duration'
+require 'grpc_kit/session/io'
+require 'grpc_kit/rpcs'
 
 module GrpcKit
   class Client
-    def initialize(host, port, io = GrpcKit::IO::Basic)
+    def initialize(host, port, interceptors: [], timeout: nil)
       @host = host
       @port = port
       @authority = "#{host}:#{port}"
-      @io = io
-    end
-
-    # @params handler [object]
-    def handle(handler)
-      klass = handler.class
-
-      klass.rpc_descs.values.each do |rpc_desc|
-        path = rpc_desc.path(klass.service_name)
-        if @rpc_descs[path]
-          raise "Duplicated method registered #{key}, class: #{handler}"
-        end
-
-        @rpc_descs[path] = [rpc_desc, handler]
-      end
-    end
-
-    class RequestResponse
-      attr_writer :session
-
-      def initialize(path, opts = {})
-        @path = path
-        @opts = opts
-        @session = nil
-        @data = ''
-      end
-
-      def invoke(data)
-        @session.submit_settings([])
-
-        stream_id = submit_request(data)
-        @session.start(stream_id)
-        @data
-      end
-
-      def on_data_chunk_recv(stream, data)
-        compressed, length, buf = data.unpack('CNa*')
-        if compressed == 0 # TODO: not
-          if length != buf.size
-            raise 'recived data inconsistent'
-          end
-
-          @data << buf
-          stream.recv2(buf)
+      @interceptors = interceptors
+      @timeout =
+        if timeout
+          GrpcKit::Session::Duration.from_numeric(timeout)
         else
-          raise 'not supported'
+          nil
         end
-      end
-
-      private
-
-      def submit_request(data)
-        @session.submit_request(
-          {
-            ':method' => 'POST',
-            ':scheme' => 'http',
-            ':authority' => @opts[:authority],
-            ':path' => @path.to_s,
-            'te' => 'trailers',
-            'content-type' => 'application/grpc',
-            'user-agent' => "grpc-ruby/#{GrpcKit::VERSION} (grpc_kit)",
-            'grpc-accept-encoding' => 'identity,deflate,gzip',
-          },
-          data,
-        )
-      end
     end
 
-    def request_response(path, request, rpc_desc, opts = {})
+    def request_response(rpc, request, opts = {})
       GrpcKit.logger.info('Calling request_respose')
-      sock = TCPSocket.new(@host, @port)
-
-      rr = RequestResponse.new(path, { authority: @authority }.merge(opts))
-      session = GrpcKit::Session::Client.new(@io.new(sock, sock), rr)
-      rr.session = session
 
-      req = rpc_desc.encode2(request)
-      data = [0, req.length, req].pack('CNa*')
-
-      resp = rr.invoke(data)
-      rpc_desc.decode2(resp)
+      rpc.config.interceptor.interceptors = @interceptors
+      do_request(rpc, request, opts)
     end
 
-    def client_streamer(path, requests, rpc, opts = {})
+    def client_streamer(rpc, opts = {})
       GrpcKit.logger.info('Calling client_streamer')
+      rpc.config.interceptor.interceptors = @interceptors
+      do_request(rpc, nil, opts)
     end
 
-    def server_streamer(path, request, metadata, opts = {})
+    def server_streamer(rpc, request, opts = {})
       GrpcKit.logger.info('Calling server_streamer')
+      rpc.config.interceptor.interceptors = @interceptors
+      do_request(rpc, request, opts)
     end
 
-    def bidi_streamer(path, requests, metadata, opts = {})
+    def bidi_streamer(rpc, requests, opts = {})
+      rpc.config.interceptor.interceptors = @interceptors
       GrpcKit.logger.info('Calling bidi_streamer')
     end
+
+    private
+
+    def do_request(rpc, request, **opts)
+      sock = TCPSocket.new(@host, @port) # XXX
+      session = GrpcKit::Session::Client.new(GrpcKit::Session::IO.new(sock), rpc)
+      session.submit_settings([])
+
+      default = { timeout: @timeout, authority: @authority }.compact
+      rpc.invoke(session, request, opts.merge(default))
+    end
   end
 end