grumlin 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e532964db5d5afd11d89978a132a5f4f7d1a4d98c740f639acadac260c93be89
-  data.tar.gz: 9015cb71bbab17895d8809dc7ff514b90e9d1ceb81ed6a9eec446a0db7ec0994
+  metadata.gz: 11e434ab0f5cd463d357e69dd3cbf5083f85a1bdd32e4d2c96023ce262704020
+  data.tar.gz: f24dd70f8b0abe9b370f77587d590802b32aa3e7b8a20380b9518004868cc6c7
 SHA512:
-  metadata.gz: a4295b9e6041726c36c05cc0aed94a645e8d7103c99351dfadef7077f14037b81daf87a4ffb1fd48105d8c1fa888e96ce173aa3be42c9b35ec58de3e289c01ed
-  data.tar.gz: 51824ca159be63be91fc798b40777a25d55f0ce423b07a9ce4ce9880002e94b4e4196bc0d92b4ca84bee86356f17fd90f3cc2dd9daa594f906fc2e93f11be422
+  metadata.gz: 5bfbd0d4db9ef46d35839b8ca5654cdc1f5038ee2c4ca004b678471380095d1fb587fa89a8df0c5a4769e3943ceb4e0b88734b701593ccf1047a05ab85baaaf5
+  data.tar.gz: a7d87e630e6b2076bedd079365e709018b3fc61f1577564c504593ffdeb4deab88f56d8785c30877489171b6c9d7fd245982475a75f4c639647c923e2ca296ef

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    grumlin (0.3.0)
+    grumlin (0.4.0)
       async-pool (~> 0.3)
       async-websocket (~> 0.19)
 
@@ -59,7 +59,7 @@ GEM
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
     minitest (5.14.4)
-    nio4r (2.5.7)
+    nio4r (2.5.8)
     nokogiri (1.11.7-x86_64-linux)
       racc (~> 1.4)
     overcommit (0.57.0)

data/lib/async/channel.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Async
+  # Channel is a wrapper around Async::Queue that provides
+  # a protocol and handy tools for passing data, exceptions and closing.
+  # It is designed to be used with only one publisher and one subscriber
+  class Channel
+    class ChannelError < StandardError; end
+
+    class ChannelClosedError < ChannelError; end
+
+    def initialize
+      @queue = Async::Queue.new
+      @closed = false
+    end
+
+    def closed?
+      @closed
+    end
+
+    # Methods for a publisher
+    def <<(payload)
+      raise(ChannelClosedError, "Cannot send to a closed channel") if @closed
+
+      @queue << [:payload, payload]
+    end
+
+    def exception(exception)
+      raise(ChannelClosedError, "Cannot send to a closed channel") if closed?
+
+      @queue << [:exception, exception]
+    end
+
+    def close
+      raise(ChannelClosedError, "Cannot close a closed channel") if closed?
+
+      @queue << [:close]
+      @closed = true
+    end
+
+    # Methods for a subscriber
+    def dequeue
+      each do |payload| # rubocop:disable Lint/UnreachableLoop this is intended
+        return payload
+      end
+    end
+
+    def each # rubocop:disable Metrics/MethodLength
+      raise(ChannelClosedError, "Cannot receive from a closed channel") if closed?
+
+      @queue.each do |type, payload|
+        case type
+        when :exception
+          payload.set_backtrace(caller + (payload.backtrace || [])) # A hack to preserve full backtrace
+          raise payload
+        when :payload
+          yield payload
+        when :close
+          break
+        end
+      end
+    end
+  end
+end

data/lib/grumlin.rb

@@ -12,6 +12,8 @@ require "async/barrier"
 require "async/http/endpoint"
 require "async/websocket/client"
 
+require_relative "async/channel"
+
 require_relative "grumlin/version"
 require_relative "grumlin/exceptions"
 
@@ -38,12 +40,13 @@ require_relative "grumlin/sugar"
 
 module Grumlin
   class Config
-    attr_accessor :url, :pool_size, :client_concurrency
+    attr_accessor :url, :pool_size, :client_concurrency, :client_factory
 
-    # For some reason, client_concurrency must be greather pool_size
+    # For some reason, client_concurrency must be greater than pool_size
     def initialize
       @pool_size = 10
       @client_concurrency = 20
+      @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
     end
 
     def default_pool

data/lib/grumlin/client.rb

@@ -2,45 +2,49 @@
 
 module Grumlin
   class Client
-    class PoolResource < self
-      attr :concurrency, :count
+    class PoolResource < Async::Pool::Resource
+      attr_reader :client
 
       def self.call
-        new(Grumlin.config.url, concurrency: Grumlin.config.client_concurrency).tap(&:connect)
+        config = Grumlin.config
+        new(config.url, client_factory: config.client_factory, concurrency: config.client_concurrency)
       end
 
-      def initialize(url, concurrency: 1, parent: Async::Task.current)
-        super(url, parent: parent)
-        @concurrency = concurrency
-        @count = 0
+      def initialize(url, client_factory:, concurrency: 1, parent: Async::Task.current)
+        super(concurrency)
+        @client = client_factory.call(url, parent).tap(&:connect)
       end
 
-      def viable?
-        connected?
+      def closed?
+        !@client.connected?
       end
 
-      def closed?
-        connected?
+      def close
+        @client.close
       end
 
-      def reusable?
-        true
+      def write(*args)
+        @client.write(*args)
       end
     end
 
-    def initialize(url, parent: Async::Task.current)
+    def initialize(url, parent: Async::Task.current, **client_options)
+      @url = url
+      @client_options = client_options
       @parent = parent
-      @transport = Transport.new(url)
       reset!
     end
 
     def connect
-      response_queue = @transport.connect
+      @transport = build_transport
+      response_channel = @transport.connect
       @request_dispatcher = RequestDispatcher.new
       @parent.async do
-        response_queue.each do |response|
+        response_channel.each do |response|
           @request_dispatcher.add_response(response)
         end
+      rescue StandardError
+        close
       end
     end
 
@@ -52,31 +56,28 @@ module Grumlin
     end
 
     def connected?
-      @transport.connected?
+      @transport&.connected? || false
     end
 
     # TODO: support yielding
     def write(*args) # rubocop:disable Metrics/MethodLength
+      raise NotConnectedError unless connected?
+
       request_id = SecureRandom.uuid
       request = to_query(request_id, args)
-      queue = @request_dispatcher.add_request(request)
+      channel = @request_dispatcher.add_request(request)
       @transport.write(request)
 
       begin
-        msg, response = queue.dequeue
-        raise response if msg == :error
-
-        return response.flat_map { |item| Typing.cast(item) } if msg == :result
-
-        raise "ERROR"
+        channel.dequeue.flat_map { |item| Typing.cast(item) }
       rescue Async::Stop
         retry if @request_dispatcher.ongoing_request?(request_id)
-        raise UnknownRequestStopped, "#{request_id} is not in the ongoing requests list"
+        raise Grumlin::UnknownRequestStoppedError, "#{request_id} is not in the ongoing requests list"
       end
     end
 
     def inspect
-      "<#{self.class} url=#{@transport.url}>"
+      "<#{self.class} url=#{@url} connected=#{connected?}>"
     end
 
     alias to_s inspect
@@ -97,6 +98,11 @@ module Grumlin
 
     def reset!
       @request_dispatcher = nil
+      @transport = nil
+    end
+
+    def build_transport
+      Transport.new(@url, parent: @parent, **@client_options)
     end
   end
 end

data/lib/grumlin/request_dispatcher.rb

@@ -29,12 +29,12 @@ module Grumlin
     def add_request(request)
       raise "ERROR" if @requests.key?(request[:requestId])
 
-      Async::Queue.new.tap do |queue|
-        @requests[request[:requestId]] = { request: request, result: [], queue: queue }
+      Async::Channel.new.tap do |channel|
+        @requests[request[:requestId]] = { request: request, result: [], channel: channel }
       end
     end
 
-    # builds a response object, when it's ready sends it to the client via a queue
+    # builds a response object, when it's ready sends it to the client via a channel
     # TODO: sometimes response does not include requestID, no idea how to handle it so far.
     def add_response(response) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       request_id = response[:requestId]
@@ -46,15 +46,15 @@ module Grumlin
 
       case SUCCESS[response.dig(:status, :code)]
       when :success
-        request[:queue] << [:result, request[:result] + [response.dig(:result, :data)]]
+        request[:channel] << request[:result] + [response.dig(:result, :data)]
         close_request(request_id)
       when :partial_content then request[:result] << response.dig(:result, :data)
       when :no_content
-        request[:queue] << [:result, []]
+        request[:channel] << []
         close_request(request_id)
       end
     rescue StandardError => e
-      request[:queue] << [:error, e]
+      request[:channel].exception(e)
       close_request(request_id)
     end
 
@@ -62,7 +62,7 @@ module Grumlin
       raise "ERROR" unless ongoing_request?(request_id)
 
       request = @requests.delete(request_id)
-      request[:queue] << nil
+      request[:channel].close
     end
 
     def ongoing_request?(request_id)

data/lib/grumlin/transport.rb

@@ -4,64 +4,72 @@ module Grumlin
   class Transport
     # A transport based on https://github.com/socketry/async
     # and https://github.com/socketry/async-websocket
-    def initialize(url, parent: Async::Task.current)
-      @endpoint = Async::HTTP::Endpoint.parse(url)
+
+    attr_reader :url
+
+    def initialize(url, parent: Async::Task.current, **client_options)
+      @url = url
       @parent = parent
-      @request_queue = Async::Queue.new
-      @response_queue = Async::Queue.new
+      @client_options = client_options
+      @request_channel = Async::Channel.new
+      @response_channel = Async::Channel.new
       reset!
     end
 
-    def url
-      @endpoint.url
-    end
-
     def connected?
       @connected
     end
 
-    def connect # rubocop:disable Metrics/MethodLength
+    def connect # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       raise AlreadyConnectedError if connected?
 
-      @connection = Async::WebSocket::Client.connect(@endpoint)
+      @connection = Async::WebSocket::Client.connect(Async::HTTP::Endpoint.parse(@url), **@client_options)
 
       @response_task = @parent.async do
         loop do
           data = @connection.read
-          @response_queue << data
+          @response_channel << data
         end
       rescue Async::Stop
-        @response_queue << nil
+        @response_channel.close
+      rescue StandardError => e
+        @response_channel.exception(e)
       end
 
       @request_task = @parent.async do
-        @request_queue.each do |message|
+        @request_channel.each do |message|
           @connection.write(message)
           @connection.flush
         end
+      rescue StandardError => e
+        @response_channel.exception(e)
       end
 
       @connected = true
 
-      @response_queue
+      @response_channel
     end
 
     def write(message)
       raise NotConnectedError unless connected?
 
-      @request_queue << message
+      @request_channel << message
     end
 
-    def close
-      raise NotConnectedError unless connected?
+    def close # rubocop:disable Metrics/MethodLength
+      return unless connected?
 
-      @request_queue << nil
+      @request_channel.close
       @request_task.wait
 
       @response_task.stop
       @response_task.wait
 
-      @connection.close
+      begin
+        @connection.close
+      rescue Errno::EPIPE
+        nil
+      end
 
       reset!
     end

data/lib/grumlin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Grumlin
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grumlin
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-29 00:00:00.000000000 Z
+date: 2021-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-pool
@@ -62,6 +62,7 @@ files:
 - gremlin_server/Dockerfile
 - gremlin_server/tinkergraph-empty.properties
 - grumlin.gemspec
+- lib/async/channel.rb
 - lib/grumlin.rb
 - lib/grumlin/anonymous_step.rb
 - lib/grumlin/client.rb